@5ss/ai-tools 2.11.1

package/dist/client-CCKGsTeI.js

@@ -0,0 +1,743 @@
+import { n as isToolError, t as ToolError } from "./errors-DoSpNHvs.js";
+import { n as requireAuth } from "./provider-CgDAlg6K.js";
+import { t as HttpService } from "./http-service-DDNCO1s4.js";
+import { n as bytesToBase64, t as base64ToBytes } from "./bytes-BxpimpQx.js";
+import { isPlainObject, isString } from "es-toolkit";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/vendors/imessage/contracts.ts
+/**
+* Host auth for Photon iMessage over **gRPC** (Node/Bun only), aligned with spectrum-ts cloud.
+*
+* Two layers (do not conflate):
+* 1. **Spectrum Cloud** — `project_id` + `project_secret` → temporary tokens
+*    (`POST /projects/{id}/imessage/tokens`), then gRPC to Photon’s managed hosts.
+* 2. **Direct gRPC** — `address` + temporary `token` when the host already has line credentials
+*    (same shape as spectrum-ts explicit `clients[]`).
+*
+* Flat object (not a Zod union) so seams can `.extend` for `provider` / `storage`.
+*
+* @see https://github.com/photon-hq/spectrum-ts/blob/main/packages/imessage/src/auth.ts
+* @see https://github.com/photon-hq/advanced-imessage-ts
+*/
+const imessageAuthSchema = z.object({
+	/** Spectrum Cloud project id (with project_secret). Preferred production path. */
+	project_id: z.string().min(1).optional().describe("Spectrum / Photon project id"),
+	project_secret: z.string().min(1).optional().describe("Spectrum / Photon project secret (Basic auth to Spectrum Cloud)"),
+	/**
+	* gRPC host:port for direct line access (e.g. imessage.spectrum.photon.codes:443 or
+	* {instanceId}.imsg.photon.codes:443). Required with `token`; omitted when using Spectrum Cloud
+	* (address is derived like spectrum-ts).
+	*/
+	address: z.string().min(1).optional().describe("gRPC host:port for direct Advanced iMessage connection"),
+	/** Temporary iMessage bearer (not the project secret). Required for direct gRPC; Spectrum mints this. */
+	token: z.string().min(1).optional().describe("Temporary iMessage gRPC bearer token"),
+	/**
+	* Dedicated instance id. With Spectrum Cloud multi-instance responses, required to pick a line;
+	* gRPC address becomes `{server}.imsg.photon.codes:443`.
+	*/
+	server: z.string().min(1).optional().describe("Dedicated iMessage instance id (Spectrum dedicated routing)"),
+	spectrum_cloud_url: z.url().optional().describe("Spectrum Cloud origin (default https://spectrum.photon.codes)"),
+	/**
+	* Override shared gRPC host (spectrum-ts `SPECTRUM_IMESSAGE_ADDRESS`).
+	* Default `imessage.spectrum.photon.codes:443`.
+	*/
+	spectrum_imessage_address: z.string().min(1).optional().describe("Shared gRPC host override (default imessage.spectrum.photon.codes:443)"),
+	tls: z.boolean().optional().describe("gRPC TLS (default true; set false only for local plaintext)")
+}).superRefine((value, ctx) => {
+	const hasProjectId = Boolean(value.project_id);
+	if (hasProjectId !== Boolean(value.project_secret)) ctx.addIssue({
+		code: "custom",
+		message: "project_id and project_secret must be provided together for Spectrum Cloud auth"
+	});
+	if (hasProjectId) return;
+	if (!value.token || !value.address) ctx.addIssue({
+		code: "custom",
+		message: "Provide project_id + project_secret (Spectrum Cloud) or address + token (direct gRPC, spectrum-ts clients shape)"
+	});
+});
+function isImessageSpectrumAuth(auth) {
+	return Boolean(auth.project_id && auth.project_secret);
+}
+/** Aliases for hosts that want a named schema export (same base + refine). */
+const imessageSpectrumAuthSchema = imessageAuthSchema;
+const imessageGrpcAuthSchema = imessageAuthSchema;
+/** @deprecated Use imessageGrpcAuthSchema — pack is gRPC-only. */
+const imessageMiddlewareAuthSchema = imessageAuthSchema;
+const imessageChatActionSchema = z.enum([
+	"typing",
+	"upload_photo",
+	"record_video",
+	"upload_video",
+	"record_voice",
+	"upload_voice",
+	"upload_document",
+	"choose_sticker",
+	"find_location",
+	"record_video_note",
+	"upload_video_note"
+]);
+const imessageSendTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid (e.g. any;-;alice@example.com)"),
+	text: z.string().min(1).describe("Message text")
+});
+const imessageMessageOutputSchema = z.object({
+	message_id: z.string().min(1).describe("Message guid (provider id for journaling)"),
+	space_id: z.string().describe("Chat guid (same as chat_id)")
+});
+const imessageEditTextInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	message_id: z.string().min(1).describe("Message guid to edit"),
+	text: z.string().min(1).describe("Replacement text")
+});
+const imessageSendChatActionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	action: imessageChatActionSchema.describe("Chat action; non-typing values map to typing start")
+});
+const imessageSetReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	message_id: z.string().min(1).describe("Message guid to react to"),
+	emoji: z.string().min(1).max(64).describe("Tapback name (love, like, dislike, laugh, emphasize, question) or an emoji character (maps to kind emoji)")
+});
+const imessageUnsendInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	message_id: z.string().min(1).describe("Message guid to unsend")
+});
+const imessageReadInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	message_id: z.string().min(1).optional().describe("Optional; Advanced iMessage markRead marks the whole chat (field kept for seam parity)")
+});
+const imessageOkOutputSchema = z.object({
+	ok: z.boolean(),
+	space_id: z.string().optional()
+});
+const MAX_MEDIA_BYTES = 20 * 1024 * 1024;
+/**
+* Clear a reaction via setReaction(isSet=false).
+* `message_id` is the **target** message guid (not a reaction-message id).
+* `emoji` must match what was set (tapback name or emoji character).
+*/
+const imessageClearReactionInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	message_id: z.string().min(1).describe("Target message guid that was reacted to"),
+	emoji: z.string().min(1).max(64).describe("Same tapback name or emoji used when setting the reaction")
+});
+const imessageSendMediaInputSchema = z.object({
+	chat_id: z.string().min(1).describe("iMessage chat guid"),
+	kind: z.enum(["photo", "document"]).describe("Media kind (presentation)"),
+	body_base64: z.string().min(1).describe("File body as base64"),
+	file_name: z.string().min(1).describe("File name including extension"),
+	caption: z.string().optional().describe("Optional caption sent as a follow-up text message"),
+	content_type: z.string().optional().describe("Optional MIME type; inferred from file_name when omitted")
+});
+const imessageDownloadFileInputSchema = z.object({
+	file_id: z.string().min(1).describe("Attachment guid (from inbound payload or upload)"),
+	file_name: z.string().min(1).optional().describe("Preferred file name for the download result"),
+	chat_id: z.string().min(1).optional().describe("Chat guid (optional for attachment download; kept for seam parity)")
+});
+const imessageDownloadFileOutputSchema = z.object({
+	file_name: z.string(),
+	file_size: z.number().optional(),
+	body_base64: z.string().describe("Downloaded file body as base64")
+});
+/**
+* Create (or resolve) a chat via Photon `chats.create`.
+* Host-only proactive / contact-delivery path — not auto-run before sendText.
+* One address = 1:1; two or more = group.
+*/
+const imessageEnsureChatInputSchema = z.object({
+	addresses: z.array(z.string().min(1)).min(1).describe("Peer phone number(s) or email(s). One address creates a 1:1 chat; two or more create a group"),
+	message: z.string().min(1).optional().describe("Optional opening text sent in the same create call"),
+	client_message_id: z.string().min(1).optional().describe("Optional idempotency key for chat creation and the optional opening send")
+});
+const imessageEnsureChatOutputSchema = z.object({
+	chat_id: z.string().min(1).describe("Chat guid for later send, edit, react, or unsend"),
+	message_id: z.string().min(1).optional().describe("Guid of the opening message when message was provided and the server returned one")
+});
+//#endregion
+//#region src/vendors/imessage/domain.ts
+var ImessageClientError = class extends ToolError {
+	failureKind;
+	constructor(input) {
+		super(input.message, {
+			code: input.code ?? "upstream",
+			retryable: input.failureKind === "outcome_unknown",
+			cause: input.cause,
+			details: {
+				failure_kind: input.failureKind,
+				...input.details
+			}
+		});
+		this.name = "ImessageClientError";
+		this.failureKind = input.failureKind;
+	}
+};
+function isImessageDefiniteRejection(error) {
+	return error instanceof ImessageClientError && error.failureKind === "definite_rejection";
+}
+function isImessageOutcomeUnknown(error) {
+	return error instanceof ImessageClientError && error.failureKind === "outcome_unknown";
+}
+/**
+* Map free-form emoji / tapback string to Photon SettableMessageReaction.
+* Known tapback names → kind; anything else → { kind: 'emoji', emoji }.
+*/
+function toSettableReaction(emoji) {
+	const trimmed = emoji.trim();
+	switch (trimmed.toLowerCase()) {
+		case "love": return { kind: "love" };
+		case "like": return { kind: "like" };
+		case "dislike": return { kind: "dislike" };
+		case "laugh": return { kind: "laugh" };
+		case "emphasize": return { kind: "emphasize" };
+		case "question": return { kind: "question" };
+		default: return {
+			kind: "emoji",
+			emoji: trimmed
+		};
+	}
+}
+function messageToOutput(chatId, message) {
+	const space = message.chatGuids && message.chatGuids.length > 0 && message.chatGuids[0] ? message.chatGuids[0] : chatId;
+	return {
+		message_id: message.guid,
+		space_id: space
+	};
+}
+/** Decode and size-check media base64 for sendMedia. */
+function decodeMediaBytes(bodyBase64) {
+	let bytes;
+	try {
+		bytes = base64ToBytes(bodyBase64);
+	} catch (error) {
+		throw new ToolError("Invalid base64 body", {
+			code: "bad_input",
+			cause: error
+		});
+	}
+	if (bytes.byteLength === 0) throw new ToolError("Media body must not be empty", { code: "bad_input" });
+	if (bytes.byteLength > 20971520) throw new ToolError("Media exceeds 20 MiB limit", {
+		code: "too_large",
+		details: {
+			max_bytes: MAX_MEDIA_BYTES,
+			content_length: bytes.byteLength
+		}
+	});
+	return bytes;
+}
+function parseDownloadChunks(input, chunks) {
+	const parts = [];
+	let fileName;
+	let totalBytes;
+	for (const frame of chunks) {
+		if (frame.type === "header" && frame.info) {
+			if (frame.info.fileName) fileName = frame.info.fileName;
+			if (typeof frame.info.totalBytes === "number") totalBytes = frame.info.totalBytes;
+		}
+		if (frame.type === "primaryChunk" && frame.data) parts.push(frame.data);
+	}
+	const total = parts.reduce((n, p) => n + p.byteLength, 0);
+	const merged = new Uint8Array(total);
+	let offset = 0;
+	for (const p of parts) {
+		merged.set(p, offset);
+		offset += p.byteLength;
+	}
+	return {
+		file_name: input.file_name ?? fileName ?? input.file_id,
+		...totalBytes !== void 0 ? { file_size: totalBytes } : total > 0 ? { file_size: total } : {},
+		body_base64: bytesToBase64(merged)
+	};
+}
+function errorName(error) {
+	return error instanceof Error ? error.name : void 0;
+}
+function sdkCode(error) {
+	if (!isPlainObject(error)) return void 0;
+	const code = error["code"];
+	return typeof code === "string" ? code : void 0;
+}
+function sdkRetryable(error) {
+	if (!isPlainObject(error)) return void 0;
+	const retryable = error["retryable"];
+	return typeof retryable === "boolean" ? retryable : void 0;
+}
+/** Map Photon SDK errors to ImessageClientError (definite vs unknown). */
+function mapSdkError(label, error) {
+	if (error instanceof ImessageClientError) throw error;
+	if (isToolError(error)) throw error;
+	const name = errorName(error);
+	if (name === "AuthenticationError") throw new ImessageClientError({
+		message: error instanceof Error && error.message || `${label}: authentication failed`,
+		failureKind: "definite_rejection",
+		code: "bad_auth",
+		cause: error
+	});
+	if (name === "NotFoundError") throw new ImessageClientError({
+		message: error instanceof Error && error.message || `${label}: not found`,
+		failureKind: "definite_rejection",
+		code: "not_found",
+		cause: error
+	});
+	if (name === "ValidationError") throw new ImessageClientError({
+		message: error instanceof Error && error.message || `${label}: invalid request`,
+		failureKind: "definite_rejection",
+		code: "bad_input",
+		cause: error
+	});
+	if (name === "RateLimitError") throw new ImessageClientError({
+		message: error instanceof Error && error.message || `${label}: rate limited`,
+		failureKind: "outcome_unknown",
+		code: "rate_limited",
+		cause: error
+	});
+	if (name === "ConnectionError") throw new ImessageClientError({
+		message: error instanceof Error && error.message || `${label}: connection failed`,
+		failureKind: "outcome_unknown",
+		code: "upstream",
+		cause: error
+	});
+	if (name === "IMessageError" || sdkCode(error) !== void 0) {
+		const retryable = sdkRetryable(error) === true;
+		throw new ImessageClientError({
+			message: error instanceof Error && error.message || `${label} failed`,
+			failureKind: retryable ? "outcome_unknown" : "definite_rejection",
+			code: "upstream",
+			cause: error,
+			details: { ...sdkCode(error) && { sdk_code: sdkCode(error) } }
+		});
+	}
+	throw new ImessageClientError({
+		message: error instanceof Error ? error.message : `${label} request failed`,
+		failureKind: "outcome_unknown",
+		cause: error
+	});
+}
+//#endregion
+//#region src/vendors/imessage/spectrum-cloud.ts
+/**
+* Spectrum Cloud iMessage token exchange + gRPC host resolution (spectrum-ts cloud path).
+*
+* project_id + project_secret → POST /projects/{id}/imessage/tokens → temporary bearer
+* (+ dedicated instance map) → createGrpcClient({ address, token }).
+*
+* @see https://github.com/photon-hq/spectrum-ts/blob/main/packages/core/src/utils/cloud.ts
+* @see https://github.com/photon-hq/spectrum-ts/blob/main/packages/imessage/src/auth.ts
+*/
+const DEFAULT_SPECTRUM_CLOUD_URL = "https://spectrum.photon.codes";
+/**
+* Shared-line gRPC host used by spectrum-ts (`SPECTRUM_IMESSAGE_ADDRESS` override).
+* @see packages/imessage/src/auth.ts in spectrum-ts
+*/
+const DEFAULT_SPECTRUM_IMESSAGE_GRPC_ADDRESS = "imessage.spectrum.photon.codes:443";
+/** Refresh when less than this many ms remain (or 10% of TTL, whichever is larger, capped by TTL). */
+const REFRESH_SKEW_MS = 6e4;
+function basicAuthHeader(projectId, projectSecret) {
+	const raw = `${projectId}:${projectSecret}`;
+	return `Basic ${typeof btoa === "function" ? btoa(raw) : Buffer.from(raw, "utf8").toString("base64")}`;
+}
+function asRecord(value) {
+	return isPlainObject(value) ? value : void 0;
+}
+function parseExpiresIn(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	if (isString(value) && /^\d+$/.test(value)) {
+		const n = Number(value);
+		if (n > 0) return n;
+	}
+	return 3600;
+}
+/**
+* Parse Spectrum Cloud success body (`{ succeed, data }` or bare token payload).
+*/
+function parseSpectrumTokenResponse(body) {
+	const root = asRecord(body);
+	if (!root) throw new ToolError("Spectrum Cloud returned a non-object token response", { code: "upstream" });
+	const payload = asRecord(root["data"]) ?? root;
+	const type = payload["type"];
+	if (type === "shared") {
+		const token = payload["token"];
+		if (!isString(token) || token.length === 0) throw new ToolError("Spectrum Cloud shared token response missing token", { code: "upstream" });
+		return {
+			type: "shared",
+			token,
+			expiresIn: parseExpiresIn(payload["expiresIn"] ?? payload["expires_in"])
+		};
+	}
+	if (type === "dedicated") {
+		const authRaw = asRecord(payload["auth"]);
+		if (!authRaw) throw new ToolError("Spectrum Cloud dedicated token response missing auth map", { code: "upstream" });
+		const auth = {};
+		for (const [instanceId, token] of Object.entries(authRaw)) if (isString(token) && token.length > 0) auth[instanceId] = token;
+		if (Object.keys(auth).length === 0) throw new ToolError("Spectrum Cloud dedicated token response has no instance tokens", { code: "upstream" });
+		const numbersRaw = asRecord(payload["numbers"]);
+		const numbers = {};
+		if (numbersRaw) for (const [instanceId, phone] of Object.entries(numbersRaw)) numbers[instanceId] = isString(phone) ? phone : null;
+		return {
+			type: "dedicated",
+			auth,
+			numbers,
+			expiresIn: parseExpiresIn(payload["expiresIn"] ?? payload["expires_in"])
+		};
+	}
+	throw new ToolError("Spectrum Cloud token response missing type shared|dedicated", {
+		code: "upstream",
+		details: { type: type ?? null }
+	});
+}
+/**
+* Map Spectrum token payload + optional preferred instance → session fields for createGrpcClient.
+*/
+function resolveSpectrumSession(data, preferredServer) {
+	if (data.type === "shared") {
+		if (preferredServer) throw new ToolError("Spectrum Cloud returned shared routing; server (dedicated instance id) must be omitted", {
+			code: "bad_auth",
+			details: { server: preferredServer }
+		});
+		return {
+			type: "shared",
+			token: data.token,
+			expiresIn: data.expiresIn
+		};
+	}
+	const instanceIds = Object.keys(data.auth);
+	const server = preferredServer ?? (instanceIds.length === 1 ? instanceIds[0] : void 0);
+	if (!server) throw new ToolError("Spectrum Cloud returned multiple dedicated instances; set auth.server to the instance id", {
+		code: "bad_auth",
+		details: { instance_ids: instanceIds }
+	});
+	const token = data.auth[server];
+	if (!token) throw new ToolError("Spectrum Cloud dedicated response has no token for auth.server", {
+		code: "bad_auth",
+		details: {
+			server,
+			instance_ids: instanceIds
+		}
+	});
+	return {
+		type: "dedicated",
+		token,
+		server,
+		expiresIn: data.expiresIn,
+		...Object.keys(data.numbers).length > 0 && { numbers: data.numbers }
+	};
+}
+/**
+* gRPC `address` spectrum-ts uses after token mint.
+* - shared → `imessage.spectrum.photon.codes:443` (or `spectrum_imessage_address`)
+* - dedicated → `{instanceId}.imsg.photon.codes:443`
+*/
+function spectrumImessageGrpcAddress(session, options = {}) {
+	if (session.type === "dedicated" && session.server) return `${session.server}.imsg.photon.codes:443`;
+	return options.sharedAddress?.trim() || "imessage.spectrum.photon.codes:443";
+}
+async function issueImessageTokens(auth, options = {}) {
+	const http = new HttpService({
+		baseURL: (auth.spectrum_cloud_url ?? "https://spectrum.photon.codes").replace(/\/$/, ""),
+		headers: {
+			Authorization: basicAuthHeader(auth.project_id, auth.project_secret),
+			Accept: "application/json"
+		},
+		label: "Spectrum Cloud",
+		...options.fetch && { fetch: options.fetch },
+		...options.signal && { signal: options.signal }
+	});
+	const path = `/projects/${encodeURIComponent(auth.project_id)}/imessage/tokens`;
+	try {
+		const { data } = await http.post(path, void 0, { label: "Spectrum Cloud iMessage tokens" });
+		return parseSpectrumTokenResponse(data);
+	} catch (error) {
+		if (error instanceof ToolError) throw error;
+		throw new ToolError("Spectrum Cloud iMessage token exchange failed", {
+			code: "upstream",
+			cause: error
+		});
+	}
+}
+/**
+* Caches Spectrum temporary tokens and refreshes before expiry.
+* `getBearer` is safe to pass as createGrpcClient `token: async () => …`.
+*/
+var SpectrumImessageTokenSource = class {
+	#auth;
+	#fetch;
+	#signal;
+	#session;
+	#expiresAtMs = 0;
+	#refresh;
+	constructor(options) {
+		this.#auth = options.auth;
+		this.#fetch = options.fetch;
+		this.#signal = options.signal;
+	}
+	/** Dedicated instance id after the first successful mint (undefined for shared). */
+	get server() {
+		return this.#session?.server;
+	}
+	/** gRPC host:port for the current session (spectrum-ts routing). */
+	get grpcAddress() {
+		if (!this.#session) return void 0;
+		return spectrumImessageGrpcAddress(this.#session, { sharedAddress: this.#auth.spectrum_imessage_address });
+	}
+	/** Ensure a session exists; returns routing fields for createGrpcClient. */
+	async ensureReady() {
+		return this.#refreshIfNeeded();
+	}
+	/** Temporary bearer for Advanced iMessage gRPC. */
+	async getBearer() {
+		return (await this.#refreshIfNeeded()).token;
+	}
+	async #refreshIfNeeded() {
+		const now = Date.now();
+		if (this.#session && now < this.#expiresAtMs) return this.#session;
+		if (!this.#refresh) this.#refresh = this.#mint().then((session) => {
+			this.#session = session;
+			const skew = Math.min(REFRESH_SKEW_MS, Math.max(5e3, Math.floor(session.expiresIn * 100)));
+			this.#expiresAtMs = Date.now() + Math.max(1e3, session.expiresIn * 1e3 - skew);
+			return session;
+		}).finally(() => {
+			this.#refresh = void 0;
+		});
+		return this.#refresh;
+	}
+	async #mint() {
+		return resolveSpectrumSession(await issueImessageTokens(this.#auth, {
+			...this.#fetch && { fetch: this.#fetch },
+			...this.#signal && { signal: this.#signal }
+		}), this.#session?.server ?? this.#auth.server);
+	}
+};
+//#endregion
+//#region src/vendors/imessage/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({ ImessageClient: () => ImessageClient });
+var ImessageClient = class ImessageClient {
+	#auth;
+	#options;
+	#im;
+	#ready;
+	#spectrum;
+	#grpcAddress;
+	constructor(auth, options = {}) {
+		const parsed = imessageAuthSchema.safeParse(auth);
+		if (!parsed.success) throw new ToolError("Invalid iMessage auth credentials", {
+			code: "bad_auth",
+			details: { issues: parsed.error.issues.map((issue) => issue.message) }
+		});
+		this.#auth = parsed.data;
+		this.#options = options;
+	}
+	static fromContext(ctx) {
+		const auth = requireAuth(ctx, imessageAuthSchema);
+		return new ImessageClient(auth, {
+			...ctx.fetch && { fetch: ctx.fetch },
+			...ctx.signal && { signal: ctx.signal }
+		});
+	}
+	/**
+	* Dedicated instance id after Spectrum mint (undefined for shared / direct gRPC).
+	* Available after the first outbound call (or after `ready()`).
+	*/
+	get server() {
+		if (this.#spectrum) return this.#spectrum.server;
+		if (!isImessageSpectrumAuth(this.#auth)) return this.#auth.server;
+	}
+	/** Resolved gRPC host:port after `ready()` / first call. */
+	get grpcAddress() {
+		return this.#grpcAddress ?? this.#spectrum?.grpcAddress;
+	}
+	/** Resolve Spectrum tokens (if needed) and construct the gRPC SDK client. */
+	async ready() {
+		await this.#sdk();
+	}
+	/** Release SDK resources. */
+	async close() {
+		if (this.#im) await this.#im.close();
+	}
+	async #sdk() {
+		if (this.#im) return this.#im;
+		this.#ready ??= this.#createSdk().catch((error) => {
+			this.#ready = void 0;
+			throw error;
+		});
+		this.#im = await this.#ready;
+		return this.#im;
+	}
+	async #createSdk() {
+		const { createGrpcClient } = await import("@photon-ai/advanced-imessage/grpc");
+		const auth = this.#auth;
+		const tls = auth.tls !== false;
+		if (isImessageSpectrumAuth(auth)) {
+			const spectrum = new SpectrumImessageTokenSource({
+				auth,
+				...this.#options.fetch && { fetch: this.#options.fetch },
+				...this.#options.signal && { signal: this.#options.signal }
+			});
+			this.#spectrum = spectrum;
+			const address = spectrumImessageGrpcAddress(await spectrum.ensureReady(), { sharedAddress: auth.spectrum_imessage_address });
+			this.#grpcAddress = address;
+			return createGrpcClient({
+				address,
+				token: async () => spectrum.getBearer(),
+				tls: true,
+				autoIdempotency: true,
+				retry: true
+			});
+		}
+		const token = auth.token;
+		const address = auth.address;
+		if (!token || !address) throw new ToolError("iMessage direct gRPC auth requires address and token when Spectrum credentials are omitted", { code: "bad_auth" });
+		this.#grpcAddress = address;
+		return createGrpcClient({
+			address,
+			token,
+			tls,
+			autoIdempotency: true,
+			retry: true
+		});
+	}
+	/**
+	* Create a chat (1:1 or group) via Photon `chats.create`.
+	* Host-only: call once for contact / proactive delivery, store `chat_id`, then sendText.
+	* Does **not** run automatically before sendText — most threads already exist from inbound user messages.
+	*/
+	async ensureChat(input) {
+		try {
+			const created = await (await this.#sdk()).chats.create(input.addresses, {
+				...input.message && { message: input.message },
+				...input.client_message_id && { clientMessageId: input.client_message_id }
+			});
+			const out = { chat_id: created.chat.guid };
+			if (created.initialMessage?.guid) out.message_id = created.initialMessage.guid;
+			return out;
+		} catch (error) {
+			mapSdkError("iMessage ensureChat", error);
+		}
+	}
+	async sendText(input) {
+		try {
+			const message = await (await this.#sdk()).messages.sendText(input.chat_id, input.text);
+			return messageToOutput(input.chat_id, message);
+		} catch (error) {
+			mapSdkError("iMessage sendText", error);
+		}
+	}
+	async editText(input) {
+		try {
+			const message = await (await this.#sdk()).messages.edit(input.chat_id, input.message_id, input.text);
+			return messageToOutput(input.chat_id, message);
+		} catch (error) {
+			mapSdkError("iMessage editText", error);
+		}
+	}
+	/**
+	* Non-typing chat actions map to typing start (presentation parity with other channels).
+	*/
+	async sendChatAction(input) {
+		try {
+			await (await this.#sdk()).chats.setTyping(input.chat_id, true);
+		} catch (error) {
+			mapSdkError("iMessage sendChatAction", error);
+		}
+	}
+	async stopTyping(input) {
+		try {
+			await (await this.#sdk()).chats.setTyping(input.chat_id, false);
+		} catch (error) {
+			mapSdkError("iMessage stopTyping", error);
+		}
+	}
+	/**
+	* Add a tapback/emoji reaction. Returns the resulting message guid (store for journaling).
+	* Clear with clearReaction using the **same target message_id + emoji** (setReaction isSet=false).
+	*/
+	async setReaction(input) {
+		try {
+			const message = await (await this.#sdk()).messages.setReaction(input.chat_id, input.message_id, toSettableReaction(input.emoji), true);
+			return messageToOutput(input.chat_id, message);
+		} catch (error) {
+			mapSdkError("iMessage setReaction", error);
+		}
+	}
+	/**
+	* Remove a reaction. `message_id` is the **target** message; `emoji` must match setReaction.
+	*/
+	async clearReaction(input) {
+		try {
+			await (await this.#sdk()).messages.setReaction(input.chat_id, input.message_id, toSettableReaction(input.emoji), false);
+		} catch (error) {
+			mapSdkError("iMessage clearReaction", error);
+		}
+	}
+	async unsend(input) {
+		try {
+			await (await this.#sdk()).messages.unsend(input.chat_id, input.message_id);
+		} catch (error) {
+			mapSdkError("iMessage unsend", error);
+		}
+	}
+	/** Mark the chat read (Advanced iMessage marks the whole conversation). */
+	async read(input) {
+		try {
+			await (await this.#sdk()).chats.markRead(input.chat_id);
+		} catch (error) {
+			mapSdkError("iMessage read", error);
+		}
+	}
+	/**
+	* Upload bytes then send attachment by GUID. Optional caption as follow-up text.
+	*/
+	async sendMedia(input) {
+		try {
+			const im = await this.#sdk();
+			const data = decodeMediaBytes(input.body_base64);
+			const uploaded = await im.attachments.upload({
+				fileName: input.file_name,
+				data
+			});
+			const message = await im.messages.sendAttachment(input.chat_id, uploaded.attachment.guid);
+			if (input.caption) await im.messages.sendText(input.chat_id, input.caption);
+			return messageToOutput(input.chat_id, message);
+		} catch (error) {
+			mapSdkError("iMessage sendMedia", error);
+		}
+	}
+	/**
+	* Download attachment bytes by attachment guid (`file_id`).
+	*/
+	async downloadFile(input) {
+		try {
+			const im = await this.#sdk();
+			const frames = [];
+			for await (const frame of im.attachments.downloadStream(input.file_id)) if (frame.type === "header") frames.push({
+				type: "header",
+				info: {
+					...frame.info.fileName && { fileName: frame.info.fileName },
+					...typeof frame.info.totalBytes === "number" && { totalBytes: frame.info.totalBytes }
+				}
+			});
+			else if (frame.type === "primaryChunk") frames.push({
+				type: "primaryChunk",
+				data: frame.data
+			});
+			return parseDownloadChunks(input, frames);
+		} catch (error) {
+			mapSdkError("iMessage downloadFile", error);
+		}
+	}
+	async answerCallback(_input) {}
+};
+//#endregion
+export { imessageSetReactionInputSchema as A, imessageMessageOutputSchema as C, imessageSendChatActionInputSchema as D, imessageReadInputSchema as E, imessageUnsendInputSchema as M, isImessageSpectrumAuth as N, imessageSendMediaInputSchema as O, imessageGrpcAuthSchema as S, imessageOkOutputSchema as T, imessageDownloadFileInputSchema as _, SpectrumImessageTokenSource as a, imessageEnsureChatInputSchema as b, resolveSpectrumSession as c, isImessageDefiniteRejection as d, isImessageOutcomeUnknown as f, imessageClearReactionInputSchema as g, imessageAuthSchema as h, DEFAULT_SPECTRUM_IMESSAGE_GRPC_ADDRESS as i, imessageSpectrumAuthSchema as j, imessageSendTextInputSchema as k, spectrumImessageGrpcAddress as l, MAX_MEDIA_BYTES as m, client_exports as n, issueImessageTokens as o, toSettableReaction as p, DEFAULT_SPECTRUM_CLOUD_URL as r, parseSpectrumTokenResponse as s, ImessageClient as t, ImessageClientError as u, imessageDownloadFileOutputSchema as v, imessageMiddlewareAuthSchema as w, imessageEnsureChatOutputSchema as x, imessageEditTextInputSchema as y };
+
+//# sourceMappingURL=client-CCKGsTeI.js.map