@krischoichoi/channel-lark 0.6.0

package/lib/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @krischoichoi/channel-lark — Lark / Feishu channel adapter for DeepSeek Harness.
+ *
+ * Maps the Lark platform to the stable Channel Contract. The upstream is the
+ * OFFICIAL `@larksuiteoapi/node-sdk` only:
+ * - inbound — WSClient + EventDispatcher (`im.message.receive_v1` +
+ *   `card.action.trigger`);
+ * - outbound — the official OpenAPI client (`im.v1.message.create` / `patch`,
+ *   media uploads, CardKit 2.0 card entities and native streaming).
+ * The AppId is a plain config string (`upstream.appId`); the AppSecret is
+ * resolved via `ctx.credentials` (`DSH_CHANNEL_LARK_MAIN_APP_SECRET`) — only
+ * the reference name ever lives in config. The secret value is never logged.
+ * There is no self-hosted gateway mode, transport injection, plaintext secret
+ * field, or runtime migration path.
+ *
+ * Lifecycle: when the Channel Control Plane (`ctx.channelControl`) is present,
+ * apply() registers a `ChannelDefinition` ('lark'); the control plane decides
+ * when to instantiate/mount the adapter (headless auto-start). When it is
+ * absent (standalone / older harness), apply() falls back to resolving SDK
+ * credentials and mounting directly — never throwing when a channel is merely
+ * unconfigured.
+ *
+ * Streaming is `edit` (CardKit 2.0 native streaming card): create card entity
+ * → send card reference → stream element content → close streaming at end.
+ * Threads are preserved (`conversation.threadId`) so Harness sessions isolate
+ * per thread. Auth is connection-state driven — the driver owns platform
+ * credentials (never logged).
+ */
+import { type Context } from '@deepseek-ai/cordis';
+import type { LarkConfig, LarkConfigLive } from './config.js';
+import { Config, LARK_APP_SECRET_REF } from './config.js';
+import { type LarkAdapterDeps } from './adapter.js';
+export declare const name = "channel-lark";
+export declare const inject: string[];
+export { Config, LARK_APP_SECRET_REF };
+export { createLarkDefinition, type LarkCredentialSeam, type CreateLarkDefinitionOptions } from './definition.js';
+export { beginLarkDeviceAuthorization, pollLarkDeviceAuthorization, type LarkDeviceAuthorizationOptions, } from './auth/device-authorization.js';
+export { LarkAdapter, resolveDomain, type LarkAdapterDeps } from './adapter.js';
+export { LarkCardReply, truncateSummary, splitForRollover, type LarkCardStatus, type LarkCardUpdate } from './card.js';
+export { InboundProcessor } from './inbound.js';
+export { OutboundSender } from './outbound.js';
+export { type LarkOutbound, type LarkUpstream, type LarkFileRef, type LarkMediaRef, type LarkStreamingCardRef, } from './upstream.js';
+export { LarkOpenApiOutbound, receiveIdType, cardContent, interactiveCardContent, streamingCardJson, STREAM_MARKDOWN_ELEMENT_ID, type LarkOpenApiClient, type LarkOpenApiOutboundOptions, type LarkCreateMessagePayload, type LarkCreateMessageResult, type LarkReceiveIdType, type LarkPatchMessagePayload, type LarkCreateImagePayload, type LarkCreateImageResult, fileTypeFromName, type LarkFileType, type LarkCreateFilePayload, type LarkCreateFileResult, type LarkApiResponse, type LarkCardkitCardCreatePayload, type LarkCardkitCardCreateResult, type LarkCardElementContentPayload, type LarkCardSettingsPayload, } from './openapi-outbound.js';
+export { LarkSdkUpstream, mapSdkMessageEvent, mapSdkCardAction, MESSAGE_EVENT_KEY, CARD_ACTION_EVENT_KEY, type LarkSdkClient, type LarkSdkDispatcher, type LarkSdkUpstreamOptions, type LarkMessageEventData, } from './lark-sdk-upstream.js';
+export { LarkOpenApiMediaPort, type LarkMediaClient, type LarkMediaPort, type LarkMediaPortOptions, type LarkResourceType, type LarkMessageResourceGetPayload, type LarkMessageResourceResult, type LarkImageGetPayload, type LarkImageCreatePayload, type LarkImageCreateResult, type LarkFileCreatePayload, type LarkFileCreateResult, } from './upstream/media-port.js';
+export { MediaHydrator, ImageHydrator, classifyIngressFailure, type MediaHydratorOptions, type ImageHydratorOptions, } from './media-hydrator.js';
+export { mapInbound, mapInteraction, toTextPayload, dedupKey, simpleHash, type LarkTextPayload, } from './mapper.js';
+export { manifest, type LarkManifest } from './manifest.js';
+export type { LarkConfigLive } from './config.js';
+/**
+ * Entry plugin apply. Accepts both the activation-time live shape (volatile
+ * fields resolve to `Volatile<T>` handles under Harness 0.2.0) and a plain
+ * snapshot (tests / programmatic mounting); plain fields pass through
+ * `resolveVolatileConfig` untouched. The shape is validated by Schemastery at
+ * the Loader boundary via the attached `Config` schema.
+ */
+export declare function apply(ctx: Context, rawConfig: LarkConfig | LarkConfigLive, deps?: LarkAdapterDeps): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -0,0 +1,104 @@
+/**
+ * @krischoichoi/channel-lark — Lark / Feishu channel adapter for DeepSeek Harness.
+ *
+ * Maps the Lark platform to the stable Channel Contract. The upstream is the
+ * OFFICIAL `@larksuiteoapi/node-sdk` only:
+ * - inbound — WSClient + EventDispatcher (`im.message.receive_v1` +
+ *   `card.action.trigger`);
+ * - outbound — the official OpenAPI client (`im.v1.message.create` / `patch`,
+ *   media uploads, CardKit 2.0 card entities and native streaming).
+ * The AppId is a plain config string (`upstream.appId`); the AppSecret is
+ * resolved via `ctx.credentials` (`DSH_CHANNEL_LARK_MAIN_APP_SECRET`) — only
+ * the reference name ever lives in config. The secret value is never logged.
+ * There is no self-hosted gateway mode, transport injection, plaintext secret
+ * field, or runtime migration path.
+ *
+ * Lifecycle: when the Channel Control Plane (`ctx.channelControl`) is present,
+ * apply() registers a `ChannelDefinition` ('lark'); the control plane decides
+ * when to instantiate/mount the adapter (headless auto-start). When it is
+ * absent (standalone / older harness), apply() falls back to resolving SDK
+ * credentials and mounting directly — never throwing when a channel is merely
+ * unconfigured.
+ *
+ * Streaming is `edit` (CardKit 2.0 native streaming card): create card entity
+ * → send card reference → stream element content → close streaming at end.
+ * Threads are preserved (`conversation.threadId`) so Harness sessions isolate
+ * per thread. Auth is connection-state driven — the driver owns platform
+ * credentials (never logged).
+ */
+import {} from '@deepseek-ai/cordis';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { mountChannelAdapter, resolveVolatileConfig, resolveVolatileValue } from '@krischoichoi/channel-core';
+import { Config, LARK_APP_SECRET_REF } from './config.js';
+import { LarkAdapter } from './adapter.js';
+import { createLarkDefinition } from './definition.js';
+export const name = 'channel-lark';
+export const inject = ['channels', 'credentials'];
+export { Config, LARK_APP_SECRET_REF };
+export { createLarkDefinition } from './definition.js';
+export { beginLarkDeviceAuthorization, pollLarkDeviceAuthorization, } from './auth/device-authorization.js';
+export { LarkAdapter, resolveDomain } from './adapter.js';
+export { LarkCardReply, truncateSummary, splitForRollover } from './card.js';
+export { InboundProcessor } from './inbound.js';
+export { OutboundSender } from './outbound.js';
+export {} from './upstream.js';
+export { LarkOpenApiOutbound, receiveIdType, cardContent, interactiveCardContent, streamingCardJson, STREAM_MARKDOWN_ELEMENT_ID, fileTypeFromName, } from './openapi-outbound.js';
+export { LarkSdkUpstream, mapSdkMessageEvent, mapSdkCardAction, MESSAGE_EVENT_KEY, CARD_ACTION_EVENT_KEY, } from './lark-sdk-upstream.js';
+export { LarkOpenApiMediaPort, } from './upstream/media-port.js';
+export { MediaHydrator, ImageHydrator, classifyIngressFailure, } from './media-hydrator.js';
+export { mapInbound, mapInteraction, toTextPayload, dedupKey, simpleHash, } from './mapper.js';
+export { manifest } from './manifest.js';
+/**
+ * Entry plugin apply. Accepts both the activation-time live shape (volatile
+ * fields resolve to `Volatile<T>` handles under Harness 0.2.0) and a plain
+ * snapshot (tests / programmatic mounting); plain fields pass through
+ * `resolveVolatileConfig` untouched. The shape is validated by Schemastery at
+ * the Loader boundary via the attached `Config` schema.
+ */
+export function apply(ctx, rawConfig, deps = {}) {
+    const config = resolveVolatileConfig(rawConfig);
+    // Adapt the CredentialProvider to the structural seam expected by the
+    // definition (credentialRef branding is applied here, once).
+    const seam = {
+        resolve: (ref) => ctx.credentials.resolve(credentialRef(ref)),
+        describe: (ref) => ctx.credentials.describe(credentialRef(ref)),
+        set: (ref, value) => ctx.credentials.set(credentialRef(ref), value),
+    };
+    const control = ctx.get('channelControl');
+    if (control) {
+        // Control plane present: register the definition EVEN when disabled — the
+        // plane owns adapter instantiation + headless auto-start, and a disabled
+        // definition must stay visible so the Web control plane can re-enable it
+        // later.
+        const settings = ctx.get('settings');
+        control.definitions.register(createLarkDefinition({
+            config,
+            deps,
+            credentials: seam,
+            persistSetup: (patch) => settings?.update('channels-lark', patch) ?? Promise.resolve(),
+            persistEnabled: (enabled) => settings?.update('channels-lark', { enabled }) ?? Promise.resolve(),
+        }));
+        return;
+    }
+    // Legacy fallback (standalone, no control plane): mount directly. An
+    // unconfigured adapter must NOT throw — log a warning and stay idle. In this
+    // mode there is no directory/control surface, so the config `enabled` gate
+    // still applies.
+    if (!resolveVolatileValue(config.enabled))
+        return;
+    ctx.effect(async () => {
+        const appId = config.upstream.appId;
+        const appSecretRef = config.upstream.appSecretRef ?? LARK_APP_SECRET_REF;
+        const appSecret = (await ctx.credentials.resolve(credentialRef(appSecretRef)))?.value;
+        if (!appId || !appSecret) {
+            ctx.logger('channel-lark').warn(`[channel-lark] not configured (missing appId or appSecret ref "${appSecretRef}"); adapter not mounted`);
+            return () => { };
+        }
+        const adapter = new LarkAdapter(config, { ...deps, appId, appSecret });
+        mountChannelAdapter(ctx, adapter, (signal) => ctx.channels.createAdapterContext({ channelId: 'lark', signal }));
+        // The mount owns the adapter lifecycle; this outer effect only scopes the
+        // async credential resolution, so its disposer is a no-op.
+        return () => { };
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/lark-sdk-upstream.d.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import type { LarkFileRef, LarkMediaRef, LarkOutbound, LarkUpstream } from './upstream.js';
+/** Event type key for inbound message delivery (v1 event). */
+export declare const MESSAGE_EVENT_KEY = "im.message.receive_v1";
+/** Official event name for Feishu interactive-card button presses. */
+export declare const CARD_ACTION_EVENT_KEY = "card.action.trigger";
+/**
+ * Minimal structural dispatcher surface consumed by the driver. The real SDK
+ * `EventDispatcher` satisfies it (register / invoke); the WS client invokes
+ * `invoke(data, { needCheck: false })` for every inbound event frame.
+ */
+export interface LarkSdkDispatcher {
+    /** Register handlers keyed by event type (e.g. 'im.message.receive_v1'). */
+    register(handles: Record<string, (...args: any[]) => unknown>): unknown;
+    /** Dispatch one raw event envelope to the registered handler. */
+    invoke(data: unknown, params?: {
+        needCheck?: boolean;
+    }): Promise<unknown>;
+}
+/**
+ * Minimal structural WS client surface consumed by the driver. The real SDK
+ * `WSClient` satisfies it (start / close); tests inject a fake without a
+ * WebSocket.
+ */
+export interface LarkSdkClient {
+    /** Open the WS long-connection and start dispatching events. */
+    start(params: {
+        eventDispatcher: LarkSdkDispatcher;
+    }): Promise<void>;
+    /** Close the WS long-connection (sync in the real SDK). */
+    close(params?: {
+        force?: boolean;
+    }): void;
+}
+export interface LarkSdkUpstreamOptions {
+    /** The WS long-connection client (real WSClient or injected fake). */
+    client: LarkSdkClient;
+    /**
+     * Official OpenAPI outbound delegate (`LarkOpenApiOutbound` in production;
+     * any `LarkOutbound` fake in tests).
+     */
+    outbound: LarkOutbound;
+    /** Official OpenAPI chat lookup; absence deliberately fails card actions closed. */
+    resolveChatType?: (conversationId: string) => Promise<'p2p' | 'group' | undefined>;
+    /** Invoked after the WS connection is established (connection state). */
+    onConnected?: () => void;
+}
+declare const larkMessageEventDataSchema: z.ZodObject<{
+    event_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    event_type: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    token: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    create_time: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    sender: z.ZodOptional<z.ZodObject<{
+        sender_id: z.ZodOptional<z.ZodObject<{
+            union_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+            user_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+            open_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        }, z.core.$loose>>;
+        sender_type: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        tenant_key: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$loose>>;
+    message: z.ZodOptional<z.ZodObject<{
+        message_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        root_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        parent_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        thread_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        create_time: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        chat_id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        chat_type: z.ZodEnum<{
+            p2p: "p2p";
+            group: "group";
+        }>;
+        message_type: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+        content: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type LarkMessageEventData = z.infer<typeof larkMessageEventDataSchema>;
+/**
+ * Map one parsed v1 message event into the canonical raw envelope consumed by
+ * the inbound mapper (`{ type, msgId, eventId, senderId, conversationId,
+ * chatType, threadId, content, ... }`). Returns `undefined` when the event
+ * carries no message body.
+ */
+export declare function mapSdkMessageEvent(input: unknown): Record<string, unknown> | undefined;
+/**
+ * Convert the official SDK-normalized card action into the canonical
+ * interaction envelope. The platform callback itself is never hand-parsed —
+ * it is first trust-boundary validated with zod and then normalized by the
+ * official SDK's `normalizeCardAction()`.
+ */
+export declare function mapSdkCardAction(input: unknown, resolveChatType: ((conversationId: string) => Promise<'p2p' | 'group' | undefined>) | undefined): Promise<Record<string, unknown> | undefined>;
+/** SDK-mode implementation of `LarkUpstream` (inbound via the SDK). */
+export declare class LarkSdkUpstream implements LarkUpstream {
+    private readonly options;
+    /**
+     * Real SDK dispatcher: the registered handler is invoked for every
+     * `im.message.receive_v1` frame the WS client delivers. Reused across
+     * reconnects (the handler is registered once per driver instance).
+     */
+    private readonly dispatcher;
+    private registered;
+    private onMessage?;
+    constructor(options: LarkSdkUpstreamOptions);
+    /**
+     * Connect the WS long-connection, route inbound message events into the
+     * canonical raw shape, and keep the connection open until `signal` aborts.
+     */
+    receive(signal: AbortSignal, onMessage: (raw: unknown) => void): Promise<void>;
+    private registerOnce;
+    sendText(to: string, text: string): Promise<unknown>;
+    sendMedia(to: string, media: LarkMediaRef): Promise<unknown>;
+    sendFile(to: string, file: LarkFileRef): Promise<unknown>;
+    sendInteractive(to: string, text: string, actions: import('@krischoichoi/channel-core').OutboundActionRow[]): Promise<unknown>;
+    updateInteractive(cardId: string, text: string, actions: import('@krischoichoi/channel-core').OutboundActionRow[]): Promise<unknown>;
+    createCardEntity(cardJson: string): Promise<{
+        cardId: string;
+    }>;
+    sendCardEntity(conversationId: string, cardId: string): Promise<{
+        messageId: string;
+    }>;
+    updateCardElementContent(cardId: string, elementId: string, content: string, sequence: number, uuid: string): Promise<unknown>;
+    finishStreamingCard(cardId: string, sequence: number, summary: string): Promise<unknown>;
+    startTyping(messageId: string): Promise<void>;
+    stopTyping(messageId: string): Promise<void>;
+    getChatType(conversationId: string): Promise<'p2p' | 'group' | undefined>;
+}
+export {};
+//# sourceMappingURL=lark-sdk-upstream.d.ts.map

package/lib/lark-sdk-upstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lark-sdk-upstream.d.ts","sourceRoot":"","sources":["../src/lark-sdk-upstream.ts"],"names":[],"mappings":"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"}

package/lib/lark-sdk-upstream.js

@@ -0,0 +1,339 @@
+/**
+ * Lark SDK upstream driver (official `@larksuiteoapi/node-sdk`).
+ *
+ * This driver is the ONLY inbound implementation: robot messages arrive over
+ * the official SDK's WebSocket long-connection (`WSClient` +
+ * `EventDispatcher`, event `im.message.receive_v1`) and interactive-card
+ * button presses arrive over `card.action.trigger`. Both are mapped into the
+ * canonical raw envelope the adapter's mapper consumes (`{ type, msgId,
+ * eventId, senderId, conversationId, chatType, threadId, ... }`) — the mapper
+ * is SDK-event-driven, there is no gateway raw shape anywhere.
+ *
+ * Thread replies are preserved: the SDK's `message.thread_id` / `root_id` /
+ * `parent_id` map into the canonical `threadId` the mapper uses to build the
+ * thread-scoped SessionBinding.
+ *
+ * OUTBOUND is delegated to the injected `LarkOutbound` — the official OpenAPI
+ * driver (`LarkOpenApiOutbound`) in production, or an injected fake in tests.
+ * This bounded split keeps the inbound and outbound legs independently
+ * swappable and fully offline-testable.
+ *
+ * Credentials never appear in this module (the client is built elsewhere from
+ * config) and are never logged. Live verification against a real Lark app
+ * (AppId/AppSecret) is a manual step — the offline tests inject a fake WS
+ * client and drive a real `EventDispatcher` with v1 event envelopes.
+ */
+import { EventDispatcher, LoggerLevel, normalizeCardAction } from '@larksuiteoapi/node-sdk';
+import { ChannelError } from '@krischoichoi/channel-core';
+import { z } from 'zod';
+/** Event type key for inbound message delivery (v1 event). */
+export const MESSAGE_EVENT_KEY = 'im.message.receive_v1';
+/** Official event name for Feishu interactive-card button presses. */
+export const CARD_ACTION_EVENT_KEY = 'card.action.trigger';
+/**
+ * Parsed v1 message event payload — the flat shape the `EventDispatcher`
+ * delivers to the `im.message.receive_v1` handler (header + event fields
+ * merged, per the SDK's RequestHandle.parse).
+ */
+const optionalStringSchema = z.string().nullish().transform((value) => value ?? undefined);
+const larkMessageEventDataSchema = z.object({
+    event_id: optionalStringSchema,
+    event_type: optionalStringSchema,
+    token: optionalStringSchema,
+    create_time: optionalStringSchema,
+    sender: z.object({
+        sender_id: z.object({
+            union_id: optionalStringSchema,
+            user_id: optionalStringSchema,
+            open_id: optionalStringSchema,
+        }).passthrough().optional(),
+        sender_type: optionalStringSchema,
+        tenant_key: optionalStringSchema,
+    }).passthrough().optional(),
+    message: z.object({
+        message_id: optionalStringSchema,
+        root_id: optionalStringSchema,
+        parent_id: optionalStringSchema,
+        thread_id: optionalStringSchema,
+        create_time: optionalStringSchema,
+        chat_id: optionalStringSchema,
+        chat_type: z.enum(['p2p', 'group']),
+        message_type: optionalStringSchema,
+        /** JSON-encoded message body per the v1 schema, e.g. '{"text":"hi"}'. */
+        content: optionalStringSchema,
+    }).passthrough().optional(),
+}).passthrough();
+const actionValueSchema = z.object({ actionId: z.string().trim().min(1) });
+// Trust-boundary validation only. Protocol normalization stays in the
+// official SDK's normalizeCardAction() implementation below.
+const officialCardActionInputSchema = z.object({
+    event_id: z.string().optional(),
+    context: z.object({
+        open_message_id: z.string().optional(),
+        open_chat_id: z.string().optional(),
+    }).optional(),
+    open_message_id: z.string().optional(),
+    open_chat_id: z.string().optional(),
+    operator: z.object({
+        open_id: z.string().optional(),
+        user_id: z.string().optional(),
+        name: z.string().optional(),
+    }).optional(),
+    action: z.object({
+        value: z.unknown().optional(),
+        tag: z.string().optional(),
+        name: z.string().optional(),
+        option: z.string().optional(),
+    }).optional(),
+}).passthrough();
+/**
+ * Map one parsed v1 message event into the canonical raw envelope consumed by
+ * the inbound mapper (`{ type, msgId, eventId, senderId, conversationId,
+ * chatType, threadId, content, ... }`). Returns `undefined` when the event
+ * carries no message body.
+ */
+export function mapSdkMessageEvent(input) {
+    const parsed = larkMessageEventDataSchema.safeParse(input);
+    if (!parsed.success) {
+        throw new ChannelError('CHANNEL_ERROR', `lark message event payload is invalid: ${zodIssueSummary(parsed.error)}`);
+    }
+    const data = parsed.data;
+    const message = data.message;
+    if (!message || typeof message !== 'object')
+        return undefined;
+    const raw = {
+        type: message.message_type,
+        msgId: message.message_id,
+        eventId: data.event_id,
+        senderId: senderIdOf(data.sender),
+        conversationId: message.chat_id,
+        // Platform chat kind ('p2p' | 'group') is authoritative for ACL identity;
+        // Feishu uses oc_ chat ids for both direct and group conversations.
+        chatType: message.chat_type,
+    };
+    // Thread preservation: the mapper keys Harness sessions by
+    // conversation.threadId, so replies inside a thread must carry the thread
+    // root. thread_id (when present) is canonical; root_id identifies the
+    // thread root; parent_id is the direct parent — a fallback for plain
+    // replies without a thread.
+    const threadId = message.thread_id ?? message.root_id ?? message.parent_id;
+    if (threadId)
+        raw.threadId = threadId;
+    const content = parseContent(message.content);
+    switch (message.message_type) {
+        case 'text':
+            raw.content = content.text;
+            break;
+        case 'image':
+            // SDK image bodies carry an image_key (not a URL); the mapper surfaces
+            // it as an opaque resourceRef resolved later by the media port.
+            raw.picUrl = content.image_key;
+            break;
+        case 'audio':
+            raw.mediaUrl = content.file_key;
+            raw.durationMs = content.duration;
+            break;
+        case 'media':
+            // Feishu video messages use message_type 'media'; the mapper knows 'video'.
+            raw.type = 'video';
+            raw.mediaUrl = content.file_key;
+            raw.durationMs = content.duration;
+            break;
+        case 'file':
+            raw.mediaUrl = content.file_key;
+            raw.title = content.file_name;
+            break;
+        case 'post':
+            raw.content = postText(content);
+            break;
+        default:
+            // Keep the SDK message_type; the mapper reports unknown types as
+            // unsupported (honest rather than guessing).
+            break;
+    }
+    return raw;
+}
+/**
+ * Convert the official SDK-normalized card action into the canonical
+ * interaction envelope. The platform callback itself is never hand-parsed —
+ * it is first trust-boundary validated with zod and then normalized by the
+ * official SDK's `normalizeCardAction()`.
+ */
+export async function mapSdkCardAction(input, resolveChatType) {
+    const parsed = officialCardActionInputSchema.safeParse(input);
+    if (!parsed.success)
+        return undefined;
+    const event = normalizeCardAction(parsed.data);
+    if (!event)
+        return undefined;
+    const value = actionValueSchema.safeParse(event.action.value);
+    if (!value.success)
+        return undefined;
+    const chatType = await resolveChatType?.(event.chatId);
+    if (!chatType)
+        return undefined;
+    return {
+        type: 'interaction',
+        msgId: event.messageId,
+        // EventDispatcher preserves the official header event_id in its flat
+        // payload. Use it when available so a later deliberate press of the same
+        // button is not collapsed with a transport retry of an earlier press.
+        eventId: parsed.data.event_id ?? `${event.messageId}:${event.operator.openId}:${value.data.actionId}`,
+        senderId: event.operator.openId,
+        conversationId: event.chatId,
+        chatType,
+        interactionId: event.messageId,
+        action: value.data.actionId,
+        value: event.action.value,
+    };
+}
+/** SDK-mode implementation of `LarkUpstream` (inbound via the SDK). */
+export class LarkSdkUpstream {
+    options;
+    /**
+     * Real SDK dispatcher: the registered handler is invoked for every
+     * `im.message.receive_v1` frame the WS client delivers. Reused across
+     * reconnects (the handler is registered once per driver instance).
+     */
+    dispatcher;
+    registered = false;
+    onMessage;
+    constructor(options) {
+        this.options = options;
+        // No verification token needed: the WS long-connection dispatches with
+        // needCheck: false (tokens/encrypt are webhook-only concerns).
+        this.dispatcher = new EventDispatcher({ loggerLevel: LoggerLevel.fatal });
+    }
+    /**
+     * Connect the WS long-connection, route inbound message events into the
+     * canonical raw shape, and keep the connection open until `signal` aborts.
+     */
+    async receive(signal, onMessage) {
+        this.onMessage = onMessage;
+        this.registerOnce();
+        try {
+            await this.options.client.start({ eventDispatcher: this.dispatcher });
+        }
+        catch (error) {
+            // Abort-driven teardown exits gracefully; other failures propagate to
+            // the adapter, which owns reconnect/backoff.
+            if (signal.aborted)
+                return;
+            throw error;
+        }
+        if (signal.aborted) {
+            this.options.client.close();
+            return;
+        }
+        this.options.onConnected?.();
+        await waitForAbort(signal);
+        this.options.client.close();
+    }
+    registerOnce() {
+        if (this.registered)
+            return;
+        this.dispatcher.register({
+            [MESSAGE_EVENT_KEY]: (data) => {
+                if (!this.onMessage)
+                    return undefined;
+                const raw = mapSdkMessageEvent(data);
+                if (raw !== undefined)
+                    this.onMessage(raw);
+                return undefined;
+            },
+            [CARD_ACTION_EVENT_KEY]: async (data) => {
+                if (!this.onMessage)
+                    return undefined;
+                const raw = await mapSdkCardAction(data, this.options.resolveChatType);
+                if (raw !== undefined)
+                    this.onMessage(raw);
+                return undefined;
+            },
+        });
+        this.registered = true;
+    }
+    sendText(to, text) {
+        return this.options.outbound.sendText(to, text);
+    }
+    sendMedia(to, media) {
+        return this.options.outbound.sendMedia(to, media);
+    }
+    sendFile(to, file) {
+        return this.options.outbound.sendFile(to, file);
+    }
+    sendInteractive(to, text, actions) {
+        return this.options.outbound.sendInteractive(to, text, actions);
+    }
+    updateInteractive(cardId, text, actions) {
+        return this.options.outbound.updateInteractive(cardId, text, actions);
+    }
+    createCardEntity(cardJson) {
+        return this.options.outbound.createCardEntity(cardJson);
+    }
+    sendCardEntity(conversationId, cardId) {
+        return this.options.outbound.sendCardEntity(conversationId, cardId);
+    }
+    updateCardElementContent(cardId, elementId, content, sequence, uuid) {
+        return this.options.outbound.updateCardElementContent(cardId, elementId, content, sequence, uuid);
+    }
+    finishStreamingCard(cardId, sequence, summary) {
+        return this.options.outbound.finishStreamingCard(cardId, sequence, summary);
+    }
+    startTyping(messageId) {
+        return this.options.outbound.startTyping?.(messageId) ?? Promise.resolve();
+    }
+    stopTyping(messageId) {
+        return this.options.outbound.stopTyping?.(messageId) ?? Promise.resolve();
+    }
+    getChatType(conversationId) {
+        return this.options.outbound.getChatType?.(conversationId) ?? Promise.resolve(undefined);
+    }
+}
+/** Open id first (the id Harness sessions key on), then union/user ids. */
+function senderIdOf(sender) {
+    const id = sender?.sender_id;
+    return id?.open_id ?? id?.union_id ?? id?.user_id;
+}
+function parseContent(content) {
+    if (!content)
+        return {};
+    try {
+        const parsed = z.record(z.string(), z.unknown()).safeParse(JSON.parse(content));
+        return parsed.success ? parsed.data : {};
+    }
+    catch {
+        return {};
+    }
+}
+function zodIssueSummary(error) {
+    return error.issues
+        .slice(0, 3)
+        .map((issue) => `${issue.path.join('.') || '<root>'}: ${issue.message}`)
+        .join('; ');
+}
+/** Best-effort plain-text extraction from a rich-text 'post' body. */
+function postText(content) {
+    const rows = content.content;
+    if (!Array.isArray(rows))
+        return '';
+    const segments = [];
+    for (const row of rows) {
+        if (!Array.isArray(row))
+            continue;
+        for (const node of row) {
+            const item = node;
+            if (item && typeof item === 'object' && typeof item.text === 'string') {
+                segments.push(item.text);
+            }
+        }
+    }
+    return segments.join('');
+}
+function waitForAbort(signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener('abort', () => resolve(), { once: true });
+    });
+}
+//# sourceMappingURL=lark-sdk-upstream.js.map