@dual-os/sdk 0.0.0-stage → 0.8.0-next.1

package/dist/AgentChannel.js

@@ -0,0 +1,734 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { validateIdentifier } from "./internal/identifier.js";
+import { PipeableProto } from "./internal/proto.js";
+import { isAuthMethod } from "./AuthMethod.js";
+import { Schema as Schema$1 } from "./ToolFile.js";
+import "./AgentChannel.js";
+import { Match, Predicate, Schema } from "effect";
+// src/AgentChannel.ts
+var AgentChannel_exports = /* @__PURE__ */ __exportAll({
+	AccessOutcome: () => AccessOutcome,
+	AgentChannel: () => AgentChannel_exports,
+	Asset: () => Asset,
+	AssetFile: () => AssetFile,
+	ChannelError: () => ChannelError,
+	CheckedResult: () => CheckedResult,
+	Content: () => Content,
+	ContextMessage: () => ContextMessage,
+	Contract: () => Contract,
+	DeliveryUpdate: () => DeliveryUpdate,
+	Destination: () => Destination,
+	Echo: () => Echo,
+	ErrorCode: () => ErrorCode,
+	Event: () => Event,
+	EventV2: () => EventV2,
+	Exposure: () => Exposure,
+	FailureCode: () => FailureCode,
+	Features: () => Features,
+	HandlerError: () => HandlerError,
+	Key: () => Key,
+	Message: () => Message,
+	Operation: () => Operation,
+	OperationKind: () => OperationKind,
+	Plan: () => Plan,
+	PlanItem: () => PlanItem,
+	Protocol: () => Protocol,
+	Reaction: () => Reaction,
+	Request: () => Request,
+	RequiredChecks: () => RequiredChecks,
+	Stop: () => Stop,
+	Timestamp: () => Timestamp,
+	TypeId: () => TypeId,
+	Verification: () => Verification,
+	VerifiedIdentity: () => VerifiedIdentity,
+	WebhookResponse: () => WebhookResponse,
+	commandSchema: () => commandSchema,
+	commandSchemaV2: () => commandSchemaV2,
+	contextResult: () => contextResult,
+	handlerKey: () => handlerKey,
+	isAgentChannel: () => isAgentChannel,
+	make: () => make,
+	projectContract: () => projectContract,
+	resultByteLimit: () => resultByteLimit,
+	resultSchema: () => resultSchema,
+	resultSchemaV2: () => resultSchemaV2,
+	schemasFor: () => schemasFor,
+	validateDefinition: () => validateDefinition
+});
+const TypeId = "@dual-os/sdk/AgentChannel";
+/** Keys are opaque and installation-scoped. Never parse them into product identities. */
+const Key = Schema.NonEmptyString.check(Schema.isMaxLength(512), Schema.isPattern(/^[^\p{Cc}]+$/u));
+/**
+* The command and result schemas a version uses. Absent means the original protocol, whose
+* projection stays byte-identical for contracts already published with it. `v2` adds the stop
+* event, conversation reads and output operations.
+*/
+const Protocol = Schema.Literals(["v2"]);
+/** What a `v2` destination can show. Every channel shows `present_outcome`. */
+const OperationKind = Schema.Literals([
+	"present_outcome",
+	"create_message",
+	"update_message",
+	"delete_message",
+	"set_reaction",
+	"set_activity",
+	"render_plan"
+]);
+const Features = Schema.Struct({
+	assets: Schema.Boolean,
+	/** Whether replaying one durable delivery key is safe at the provider boundary. */
+	deliveryMode: Schema.Literals(["idempotent", "at-most-once"]),
+	deliveryState: Schema.Boolean,
+	directText: Schema.Literal(true),
+	groups: Schema.Boolean,
+	/** Maximum Unicode code points per physical text message, including server-added prefixes. */
+	maxTextLength: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+	mentions: Schema.Boolean,
+	/** `v2` only: the output operations every destination of this version shows. */
+	operations: Schema.optionalKey(Schema.Array(OperationKind)),
+	/** `v2` only: whether `read_context` returns the conversation's earlier messages. */
+	readContext: Schema.optionalKey(Schema.Boolean),
+	replies: Schema.Boolean,
+	/** Maximum age of the original responding input before preparation and delivery. */
+	responseWindowMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+	threads: Schema.Boolean
+});
+const HttpUrl = Schema.String.check(Schema.isMaxLength(8192), Schema.makeFilter((value) => {
+	const url = URL.parse(value);
+	return url !== null && (url.protocol === "https:" || url.protocol === "http:") && url.username === "" && url.password === "";
+}));
+const Text = Schema.String.check(Schema.isMaxLength(65536));
+const ExtensionKey = Schema.String.check(Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*\/[a-z0-9]+(?:-[a-z0-9]+)*$/));
+const Extensions = Schema.Record(Schema.String, Schema.Json).check(Schema.makeFilter((values) => Object.keys(values).every(Schema.is(ExtensionKey))));
+const Destination = Schema.Struct({
+	conversationKey: Key,
+	kind: Schema.Literals(["direct", "group"]),
+	threadKey: Schema.optionalKey(Key)
+});
+const Asset = Schema.Struct({
+	assetKey: Key,
+	mediaType: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	url: HttpUrl
+});
+const Content = Schema.Struct({
+	assets: Schema.optionalKey(Schema.Array(Asset).check(Schema.isMaxLength(20))),
+	mentions: Schema.optionalKey(Schema.Array(Key).check(Schema.isMaxLength(100))),
+	replyToMessageKey: Schema.optionalKey(Key),
+	text: Text
+}).check(Schema.makeFilter((content) => content.text.length > 0 || (content.assets?.length ?? 0) > 0));
+/** The body is the unmodified UTF-8 provider body, before JSON parsing/signature verification. */
+const Request = Schema.Struct({
+	body: Schema.String.check(Schema.isMaxLength(1048576), Schema.makeFilter((body) => new TextEncoder().encode(body).byteLength <= 1048576)),
+	headers: Schema.Record(Schema.NonEmptyString.check(Schema.isMaxLength(256)), Schema.String.check(Schema.isMaxLength(8192))),
+	method: Schema.Literals([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]),
+	url: HttpUrl
+});
+const ResponseHeaders = Schema.Record(Schema.NonEmptyString.check(Schema.isMaxLength(256), Schema.isPattern(/^[a-z0-9-]+$/)), Schema.String.check(Schema.isMaxLength(8192))).check(Schema.makeFilter((headers) => Object.keys(headers).every((name) => name === "content-type" || name === "cache-control")));
+/**
+* Bounded provider-required webhook response, returned only after request verification. A 204 or
+* 205 response has an empty body.
+*/
+const WebhookResponse = Schema.Struct({
+	body: Schema.String.check(Schema.isMaxLength(65536), Schema.makeFilter((body) => new TextEncoder().encode(body).byteLength <= 65536)),
+	headers: Schema.optionalKey(ResponseHeaders),
+	status: Schema.Int.check(Schema.isBetween({
+		maximum: 299,
+		minimum: 200
+	}))
+}).check(Schema.makeFilter((response) => response.status !== 204 && response.status !== 205 || response.body === ""));
+const Timestamp = Schema.String.check(Schema.isMaxLength(64), Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/), Schema.makeFilter((value) => {
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+	const days = month === 2 ? leap ? 29 : 28 : [
+		4,
+		6,
+		9,
+		11
+	].includes(month) ? 30 : 31;
+	return month >= 1 && month <= 12 && day >= 1 && day <= days && Number(value.slice(11, 13)) < 24 && Number(value.slice(14, 16)) < 60 && Number(value.slice(17, 19)) < 60 && Schema.decodeUnknownExit(Schema.DateTimeUtcFromString)(value)._tag === "Success";
+}));
+const VerifiedIdentity = Schema.Struct({
+	conversation: Destination,
+	senderKey: Key
+});
+const AccessOutcome = Schema.Struct({ decision: Schema.Literals(["allow", "deny"]) });
+const Verification = Schema.Struct({ verified: Schema.Literal(true) });
+const Exposure = Schema.Literals(["webhook", "host"]);
+const RequiredChecks = Schema.Tuple([Schema.Literal("access")]);
+const Message = Schema.Struct({
+	content: Content,
+	conversation: Destination,
+	eventKey: Key,
+	extensions: Schema.optionalKey(Extensions),
+	kind: Schema.Literal("message"),
+	messageKey: Key,
+	respond: Schema.Boolean,
+	senderKey: Key,
+	timestamp: Timestamp
+});
+const DeliveryUpdate = Schema.Struct({
+	deliveryKey: Key,
+	deliveryUpdateKey: Key,
+	eventKey: Key,
+	extensions: Schema.optionalKey(Extensions),
+	kind: Schema.Literal("delivery_update"),
+	providerDeliveryKey: Key,
+	sequence: Schema.Natural,
+	status: Schema.Literals(["succeeded", "failed"]),
+	timestamp: Timestamp
+});
+/** Provider-confirmed own output. No content is accepted or added to conversation history. */
+const Echo = Schema.Struct({
+	...VerifiedIdentity.fields,
+	eventKey: Key,
+	extensions: Schema.optionalKey(Extensions),
+	kind: Schema.Literal("echo"),
+	messageKey: Key,
+	timestamp: Timestamp
+});
+const Event = Schema.Union([
+	Message,
+	Echo,
+	DeliveryUpdate
+]);
+/** `v2`: the sender asked the agent to stop working in this conversation. Access applies. */
+const Stop = Schema.Struct({
+	...VerifiedIdentity.fields,
+	eventKey: Key,
+	extensions: Schema.optionalKey(Extensions),
+	kind: Schema.Literal("stop"),
+	timestamp: Timestamp
+});
+const EventV2 = Schema.Union([
+	Message,
+	Echo,
+	DeliveryUpdate,
+	Stop
+]);
+/** The reactions every `v2` provider can show. Each provider maps them to its own emoji. */
+const Reaction = Schema.Literals([
+	"thumbs_up",
+	"thumbs_down",
+	"laugh",
+	"confused",
+	"heart",
+	"hooray",
+	"rocket",
+	"eyes"
+]);
+const ShortText = Schema.NonEmptyString.check(Schema.isMaxLength(200));
+const PlanItem = Schema.Struct({
+	itemKey: Key,
+	note: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(2e3))),
+	state: Schema.Literals([
+		"pending",
+		"in_progress",
+		"completed",
+		"failed"
+	]),
+	title: Schema.NonEmptyString.check(Schema.isMaxLength(256))
+});
+/** A whole task list, always sent complete. Item keys are unique and stable across revisions. */
+const Plan = Schema.Struct({
+	items: Schema.Array(PlanItem).check(Schema.isMaxLength(50), Schema.makeFilter((items) => new Set(items.map((item) => item.itemKey)).size === items.length)),
+	title: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(256)))
+});
+/**
+* One piece of `v2` output. A `reference` is the `providerDeliveryKey` the provider returned for
+* the message or plan it made; only that provider reads it.
+*/
+const Operation = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("present_outcome"),
+		options: Schema.optionalKey(Schema.Array(ShortText).check(Schema.isMaxLength(10))),
+		outcome: Schema.Literals([
+			"completed",
+			"failed",
+			"awaiting_input"
+		]),
+		text: Text
+	}).check(Schema.makeFilter((operation) => operation.options === void 0 || operation.outcome === "awaiting_input")),
+	Schema.Struct({
+		kind: Schema.Literal("create_message"),
+		messageKey: Key,
+		text: Text.check(Schema.isMinLength(1))
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("update_message"),
+		messageKey: Key,
+		reference: Key,
+		text: Text.check(Schema.isMinLength(1))
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("delete_message"),
+		messageKey: Key,
+		reference: Key
+	}),
+	Schema.Struct({
+		active: Schema.Boolean,
+		kind: Schema.Literal("set_reaction"),
+		reaction: Reaction,
+		target: Schema.Union([Schema.Struct({ kind: Schema.Literal("activation") }), Schema.Struct({
+			kind: Schema.Literal("message"),
+			reference: Key
+		})])
+	}),
+	Schema.Struct({
+		activity: Schema.Union([Schema.Struct({
+			kind: Schema.Literal("working"),
+			text: Schema.optionalKey(ShortText)
+		}), Schema.Struct({ kind: Schema.Literal("idle") })]),
+		kind: Schema.Literal("set_activity")
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("render_plan"),
+		plan: Plan,
+		reference: Schema.optionalKey(Key),
+		revision: Schema.Int.check(Schema.isGreaterThan(0))
+	})
+]);
+/** A message read back from the provider's conversation history. */
+const ContextMessage = Schema.Struct({
+	messageKey: Key,
+	/** The agent's own message. */
+	own: Schema.Boolean,
+	senderKey: Key,
+	senderName: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(256))),
+	text: Text,
+	timestamp: Timestamp
+});
+/** Decoded originals are limited separately by the host; ordinary command JSON stays bounded. */
+const AssetFile = Schema$1.check(Schema.makeFilter((file) => file.sizeBytes > 0 && file.sizeBytes <= 10485760 && file.contentBase64.length <= 13981016));
+/** Closed error vocabulary: provider messages, payloads, and causes never cross this seam. */
+const FailureCode = Schema.Literals([
+	"rejected",
+	"unauthorized",
+	"rate_limited",
+	"unavailable",
+	"unknown_completion",
+	"window_closed"
+]);
+var HandlerError = class extends Schema.TaggedError()("AgentChannelHandlerError", { code: FailureCode }) {};
+const ErrorCode = Schema.Literals([
+	"invalid_definition",
+	"not_found",
+	"invalid_input",
+	"invalid_auth",
+	"unsupported_feature",
+	"invalid_result",
+	"handler_unavailable",
+	"provider_failure"
+]);
+var ChannelError = class extends Schema.TaggedError()("AgentChannelError", {
+	code: ErrorCode,
+	providerCode: Schema.optionalKey(FailureCode)
+}) {
+	get message() {
+		return `Agent Channel ${this.code}`;
+	}
+};
+const installedCommandSchema = (state) => {
+	const operation = {
+		extensions: Schema.optionalKey(Extensions),
+		operationKey: Key
+	};
+	const installed = {
+		...operation,
+		installationKey: Key,
+		state
+	};
+	return Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("activate"),
+			...operation,
+			ingressUrl: HttpUrl,
+			state: Schema.optionalKey(state)
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deactivate"),
+			...installed
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("receive"),
+			...installed,
+			request: Request
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...installed,
+			deliveryKey: Key,
+			destination: Destination,
+			content: Content,
+			/** Original responding input timestamp; retries must preserve this reference. */
+			responseToTimestamp: Schema.optionalKey(Timestamp)
+		})
+	]);
+};
+const installedCommandSchemaV2 = (state) => {
+	const operation = {
+		extensions: Schema.optionalKey(Extensions),
+		operationKey: Key
+	};
+	const installed = {
+		...operation,
+		installationKey: Key,
+		state
+	};
+	return Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("activate"),
+			...operation,
+			ingressUrl: HttpUrl,
+			state: Schema.optionalKey(state)
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deactivate"),
+			...installed
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("receive"),
+			...installed,
+			request: Request
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...installed,
+			/** The provider message that started the turn, when the host knows it. */
+			activationMessageKey: Schema.optionalKey(Key),
+			deliveryKey: Key,
+			destination: Destination,
+			operation: Operation,
+			/** Original responding input timestamp; retries must preserve this reference. */
+			responseToTimestamp: Schema.optionalKey(Timestamp)
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("read_context"),
+			...installed,
+			destination: Destination,
+			limit: Schema.Int.check(Schema.isBetween({
+				maximum: 200,
+				minimum: 1
+			}))
+		})
+	]);
+};
+const installedResultSchema = (state) => {
+	const operation = {
+		extensions: Schema.optionalKey(Extensions),
+		operationKey: Key
+	};
+	return Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("activate"),
+			...operation,
+			installationKey: Key,
+			state,
+			/** Durable read-only provider state that the host must persist before retrying activation. */
+			checkpoint: Schema.optionalKey(Schema.Literal(true)),
+			/** The host must observe a verified webhook handshake before cutover. */
+			verification: Schema.optionalKey(Schema.Literal("ingress"))
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deactivate"),
+			...operation
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("receive"),
+			...operation,
+			verified: Schema.Literal(true),
+			deniedEventKeys: Schema.optionalKey(Schema.Array(Key).check(Schema.isMaxLength(100))),
+			events: Schema.Array(Event).check(Schema.isMaxLength(100)),
+			response: Schema.optionalKey(WebhookResponse),
+			/** A provider-native setup challenge or ping proved the configured ingress. */
+			activationProof: Schema.optionalKey(Schema.Literal("verified"))
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("succeeded"),
+			providerDeliveryKey: Key
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("pending"),
+			providerDeliveryKey: Key
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("failed"),
+			code: Schema.Literals([
+				"rejected",
+				"unauthorized",
+				"rate_limited",
+				"unavailable",
+				"window_closed"
+			])
+		})
+	]);
+};
+const installedResultSchemaV2 = (state) => {
+	const operation = {
+		extensions: Schema.optionalKey(Extensions),
+		operationKey: Key
+	};
+	return Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("activate"),
+			...operation,
+			installationKey: Key,
+			state,
+			/** Durable read-only provider state that the host must persist before retrying activation. */
+			checkpoint: Schema.optionalKey(Schema.Literal(true)),
+			/** The host must observe a verified webhook handshake before cutover. */
+			verification: Schema.optionalKey(Schema.Literal("ingress"))
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deactivate"),
+			...operation
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("receive"),
+			...operation,
+			verified: Schema.Literal(true),
+			deniedEventKeys: Schema.optionalKey(Schema.Array(Key).check(Schema.isMaxLength(100))),
+			events: Schema.Array(EventV2).check(Schema.isMaxLength(100)),
+			response: Schema.optionalKey(WebhookResponse),
+			/** A provider-native setup challenge or ping proved the configured ingress. */
+			activationProof: Schema.optionalKey(Schema.Literal("verified"))
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("succeeded"),
+			providerDeliveryKey: Key
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("pending"),
+			providerDeliveryKey: Key
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("deliver"),
+			...operation,
+			deliveryKey: Key,
+			status: Schema.Literal("failed"),
+			code: Schema.Literals([
+				"rejected",
+				"unauthorized",
+				"rate_limited",
+				"unavailable",
+				"window_closed"
+			])
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("read_context"),
+			...operation,
+			messages: Schema.Array(ContextMessage).check(Schema.isMaxLength(200))
+		})
+	]);
+};
+const readAssetCommand = (state) => Schema.Struct({
+	asset: Asset,
+	extensions: Schema.optionalKey(Extensions),
+	identity: VerifiedIdentity,
+	installationKey: Key,
+	kind: Schema.Literal("read_asset"),
+	operationKey: Key,
+	state
+});
+const readAssetResult = Schema.Struct({
+	assetKey: Key,
+	extensions: Schema.optionalKey(Extensions),
+	file: AssetFile,
+	kind: Schema.Literal("read_asset"),
+	operationKey: Key
+});
+const commandSchema = (state) => Schema.Union([installedCommandSchema(state), readAssetCommand(state)]);
+const resultSchema = (state) => Schema.Union([installedResultSchema(state), readAssetResult]);
+const commandSchemaV2 = (state) => Schema.Union([installedCommandSchemaV2(state), readAssetCommand(state)]);
+const resultSchemaV2 = (state) => Schema.Union([installedResultSchemaV2(state), readAssetResult]);
+/** Maximum UTF-8 bytes in an ordinary Channel command or result, including its JSON envelope. */
+const resultByteLimit = 2097152;
+/** Keep the newest context messages within the checked result budget, oldest first. */
+function contextResult(operationKey, context) {
+	const messages = [];
+	const result = {
+		kind: "read_context",
+		messages,
+		operationKey
+	};
+	const encoder = new TextEncoder();
+	let bytes = encoder.encode(JSON.stringify(result)).byteLength;
+	for (let index = context.length - 1; index >= 0; index--) {
+		const message = context[index];
+		if (message === void 0) continue;
+		const size = encoder.encode(JSON.stringify(message)).byteLength + 1;
+		if (bytes + size > 2097152) break;
+		bytes += size;
+		messages.unshift(message);
+	}
+	return result;
+}
+/** The command and result schemas of a Channel's protocol. */
+const schemasFor = (definition) => definition.protocol === "v2" ? {
+	command: commandSchemaV2(definition.state),
+	result: resultSchemaV2(definition.state),
+	typeResult: resultSchemaV2(Schema.toType(definition.state))
+} : {
+	command: commandSchema(definition.state),
+	result: resultSchema(definition.state),
+	typeResult: resultSchema(Schema.toType(definition.state))
+};
+/**
+* Encoded, JSON-safe runtime result suitable for host persistence. It accepts both protocols;
+* a `v1` result decodes unchanged.
+*/
+const CheckedResult = resultSchemaV2(Schema.Json);
+/** Immutable catalog projection. Live schemas remain the execution validators. */
+const Contract = Schema.Struct({
+	definitionSettingsSchemaJson: Schema.Json,
+	deploymentSettingsSchemaJson: Schema.Json,
+	exposure: Exposure,
+	extensionsSchemaJson: Schema.Record(Schema.String, Schema.Json),
+	featuresJson: Features,
+	operationInputSchemaJson: Schema.Json,
+	operationOutputSchemaJson: Schema.Json,
+	protocol: Schema.optionalKey(Protocol),
+	requiredChecks: RequiredChecks,
+	stateSchemaJson: Schema.Json
+});
+/** Project the exact declaration once for SDK discovery and server contract comparison. */
+const projectContract = (definition, project = (schema) => Schema.toJsonSchemaDocument(schema, { onExcessProperty: "error" })) => {
+	const schemas = schemasFor(definition);
+	return Schema.decodeUnknownSync(Contract)({
+		definitionSettingsSchemaJson: project(definition.definitionSettings),
+		deploymentSettingsSchemaJson: project(definition.deploymentSettings),
+		exposure: definition.exposure,
+		extensionsSchemaJson: Object.fromEntries(Object.entries(definition.extensions ?? {}).map(([key, schema]) => [key, project(schema)])),
+		featuresJson: definition.features,
+		operationInputSchemaJson: project(schemas.command),
+		operationOutputSchemaJson: project(schemas.result),
+		...definition.protocol === void 0 ? {} : { protocol: definition.protocol },
+		requiredChecks: definition.requiredChecks,
+		stateSchemaJson: project(definition.state)
+	}, { onExcessProperty: "error" });
+};
+const handlerKey = (channelId) => `@dual-os/sdk/AgentChannel/Handler/${channelId}`;
+const SchemaDefinition = Schema.declare(Schema.isSchema);
+const checkSchema = (schema, allowOpaque = false) => {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (ast) => {
+		if (seen.has(ast)) return;
+		seen.add(ast);
+		if (ast.annotations?.["parseOptions"] !== void 0 || (ast.checks?.some((check) => check.annotations?.["parseOptions"] !== void 0) ?? false)) throw new ChannelError({ code: "invalid_definition" });
+		ast.encoding?.forEach((link) => {
+			visit(link.to);
+		});
+		Match.value(ast).pipe(Match.tag("Unknown", "Any", "ObjectKeyword", () => {
+			throw new ChannelError({ code: "invalid_definition" });
+		}), Match.tag("Declaration", (declaration) => {
+			if (!allowOpaque) throw new ChannelError({ code: "invalid_definition" });
+			declaration.typeParameters.forEach(visit);
+		}), Match.tag("Objects", (objects) => {
+			objects.propertySignatures.forEach((property) => visit(property.type));
+			objects.indexSignatures.forEach((index) => {
+				if (index.parameter._tag !== "String" || index.parameter.checks !== void 0 || index.parameter.encoding !== void 0) throw new ChannelError({ code: "invalid_definition" });
+				visit(index.parameter);
+				visit(index.type);
+			});
+		}), Match.tag("Arrays", (arrays) => {
+			arrays.elements.forEach(visit);
+			arrays.rest.forEach(visit);
+		}), Match.tag("Union", (union) => {
+			union.types.forEach(visit);
+		}), Match.tag("Suspend", (suspend) => {
+			visit(suspend.thunk());
+		}), Match.orElse(() => void 0));
+	};
+	visit(schema.ast);
+};
+const DefinitionSchema = Schema.Struct({
+	authMethods: Schema.Array(Schema.declare(isAuthMethod)),
+	definitionSettings: SchemaDefinition,
+	deploymentSettings: SchemaDefinition,
+	exposure: Exposure,
+	extensions: Schema.optionalKey(Schema.Record(Schema.String, SchemaDefinition).check(Schema.makeFilter((values) => Object.keys(values).every(Schema.is(ExtensionKey))))),
+	features: Features,
+	protocol: Schema.optionalKey(Protocol),
+	requiredChecks: RequiredChecks,
+	state: SchemaDefinition
+}).check(Schema.makeFilter(({ features, protocol }) => {
+	if (protocol === void 0) return features.operations === void 0 && features.readContext === void 0;
+	const operations = features.operations ?? [];
+	return operations.includes("present_outcome") && new Set(operations).size === operations.length && (features.maxTextLength === void 0 || operations.includes("create_message"));
+}));
+/** Validate declarations at registration as well as at builder time. */
+const validateDefinition = (definition, providerId, methods) => {
+	try {
+		Schema.decodeUnknownSync(DefinitionSchema)(definition, { onExcessProperty: "error" });
+		for (const schema of [
+			definition.definitionSettings,
+			definition.deploymentSettings,
+			definition.state,
+			...Object.values(definition.extensions ?? {})
+		]) {
+			checkSchema(schema);
+			Schema.toJsonSchemaDocument(schema);
+		}
+		const seen = /* @__PURE__ */ new Set();
+		for (const method of definition.authMethods) {
+			if (seen.has(method.identifier) || methods !== void 0 && !methods.includes(method)) throw new ChannelError({ code: "invalid_definition" });
+			seen.add(method.identifier);
+			Schema.decodeUnknownSync(SchemaDefinition)(method.material);
+			Schema.decodeUnknownSync(SchemaDefinition)(method.value);
+			for (const schema of [
+				method.material,
+				method.value,
+				...method.setup === void 0 ? [] : [method.setup]
+			]) checkSchema(schema, true);
+		}
+		if (providerId !== void 0 && Object.keys(definition.extensions ?? {}).some((key) => !key.startsWith(`${providerId}/`))) throw new ChannelError({ code: "invalid_definition" });
+	} catch {
+		throw new ChannelError({ code: "invalid_definition" });
+	}
+};
+/** Create a Channel from its contract. */
+const make = (identifier, options) => {
+	validateIdentifier("agent-channel", identifier);
+	const { description, name, ...definition } = options;
+	validateDefinition(definition);
+	return {
+		...PipeableProto,
+		[TypeId]: TypeId,
+		definition: Object.freeze({
+			...definition,
+			authMethods: Object.freeze([...definition.authMethods]),
+			features: Object.freeze({ ...definition.features }),
+			requiredChecks: Object.freeze([...definition.requiredChecks]),
+			...definition.extensions === void 0 ? {} : { extensions: Object.freeze({ ...definition.extensions }) }
+		}),
+		description,
+		identifier,
+		name
+	};
+};
+const isAgentChannel = (value) => Predicate.hasProperty(value, TypeId);
+export { AccessOutcome, AgentChannel_exports as AgentChannel, AgentChannel_exports, Asset, AssetFile, ChannelError, CheckedResult, Content, ContextMessage, Contract, DeliveryUpdate, Destination, Echo, ErrorCode, Event, EventV2, Exposure, FailureCode, Features, HandlerError, Key, Message, Operation, OperationKind, Plan, PlanItem, Protocol, Reaction, Request, RequiredChecks, Stop, Timestamp, TypeId, Verification, VerifiedIdentity, WebhookResponse, commandSchema, commandSchemaV2, contextResult, handlerKey, isAgentChannel, make, projectContract, resultByteLimit, resultSchema, resultSchemaV2, schemasFor, validateDefinition };
+
+//# sourceMappingURL=AgentChannel.js.map