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

package/dist/AgentChannelConformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChannelConformance.d.ts","names":["AgentChannel.ChannelError","DualRuntime.Service"],"sources":["../src/AgentChannelConformance.ts"],"mappings":";;;;;;;qBAWa,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAUR,iBAAiB,QAAQ;;;;;qBACxB,yBAAyB;;;;;;;;qBAezB,MAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoFC,OAAA,kBAAAA,eAAA,mBAAA,OAAA,aAAAC"}

package/dist/AgentChannelConformance.js

@@ -0,0 +1,163 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { EventV2, Key, commandSchema, commandSchemaV2 } from "./AgentChannel.js";
+import { Service } from "./DualRuntime.js";
+import "./AgentChannelConformance.js";
+import { Effect, Schema } from "effect";
+//#region src/AgentChannelConformance.ts
+/** Public replay conformance suite for channel plugins, runnable with @effect/vitest. */
+var AgentChannelConformance_exports = /* @__PURE__ */ __exportAll({
+	AgentChannelConformance: () => AgentChannelConformance_exports,
+	ConformanceError: () => ConformanceError,
+	Fixture: () => Fixture,
+	run: () => run
+});
+const Command = Schema.Union([commandSchema(Schema.Json), commandSchemaV2(Schema.Json)]);
+const Fixture = Schema.Struct({
+	activate: Command,
+	channelId: Key,
+	connectionId: Schema.optionalKey(Key),
+	deactivate: Command,
+	definitionSettings: Schema.Json,
+	deliver: Command,
+	deploymentSettings: Schema.Json,
+	receive: Command
+});
+var ConformanceError = class extends Schema.TaggedError()("AgentChannelConformanceError", {
+	command: Schema.Literals([
+		"activate",
+		"deactivate",
+		"receive",
+		"deliver"
+	]),
+	rule: Schema.Literals([
+		"command_kind",
+		"stable_result",
+		"stable_events",
+		"boundary_rejection"
+	])
+}) {};
+/**
+* Replays operations that providers declare safe to replay. At-most-once delivery executes once;
+* the durable host owns its replay prohibition. Use an isolated provider test installation: this
+* suite performs provider effects. The host supplies stable keys; the plugin must recover the same
+* external subscription and emit the same provider event keys, even for a fresh receipt key.
+* Boundary rejection and feature/auth matrices are covered by the SDK's public runtime tests.
+*/
+const run = Effect.fn("AgentChannelConformance.run")(function* (input) {
+	const fixture = yield* Schema.decodeUnknownEffect(Fixture)(input, { onExcessProperty: "error" });
+	const runtime = yield* Service;
+	const definition = yield* runtime.getAgentChannel({ channelId: fixture.channelId });
+	const { activate, receive, deliver, deactivate, ...config } = fixture;
+	const { connectionId: _connectionId, ...withoutConnection } = config;
+	const probes = [
+		{
+			code: "invalid_input",
+			input: {
+				...config,
+				channelId: "",
+				command: activate
+			}
+		},
+		{
+			input: {
+				...config,
+				channelId: "conformance/missing/channel",
+				command: activate
+			},
+			code: "not_found"
+		},
+		{
+			code: "invalid_input",
+			input: {
+				...config,
+				command: {
+					...activate,
+					operationKey: ""
+				}
+			}
+		},
+		{
+			code: "invalid_input",
+			input: {
+				...config,
+				agent: { id: "synthetic-authority" },
+				command: activate
+			}
+		},
+		{
+			code: "invalid_auth",
+			input: definition.authMethods.length === 0 ? {
+				...config,
+				command: activate,
+				connectionId: "unexpected"
+			} : {
+				...withoutConnection,
+				command: activate
+			}
+		}
+	];
+	for (const probe of probes) {
+		const outcome = yield* Effect.suspend(() => runtime.executeAgentChannel(probe.input)).pipe(Effect.result);
+		if (outcome._tag !== "Failure" || outcome.failure.code !== probe.code) return yield* new ConformanceError({
+			command: "activate",
+			rule: "boundary_rejection"
+		});
+	}
+	const commands = [
+		["activate", activate],
+		["receive", receive],
+		["deliver", deliver],
+		["deactivate", deactivate]
+	];
+	for (const [kind, command] of commands) if (command.kind !== kind) return yield* new ConformanceError({
+		command: kind,
+		rule: "command_kind"
+	});
+	const activated = yield* Effect.acquireRelease(runtime.executeAgentChannel({
+		...config,
+		command: activate
+	}), (result) => runtime.executeAgentChannel({
+		...config,
+		command: {
+			...deactivate,
+			...result.kind === "activate" ? {
+				installationKey: result.installationKey,
+				state: result.state
+			} : {}
+		}
+	}).pipe(Effect.orDie));
+	for (const [kind, command] of commands) {
+		const first = kind === "activate" ? activated : yield* runtime.executeAgentChannel({
+			...config,
+			command
+		});
+		if (kind === "deliver" && definition.features.deliveryMode === "at-most-once") continue;
+		const second = yield* runtime.executeAgentChannel({
+			...config,
+			command
+		});
+		const firstJson = yield* Schema.decodeUnknownEffect(Schema.Json)(first);
+		const secondJson = yield* Schema.decodeUnknownEffect(Schema.Json)(second);
+		if (!Schema.toEquivalence(Schema.Json)(firstJson, secondJson)) return yield* new ConformanceError({
+			command: kind,
+			rule: "stable_result"
+		});
+		if (kind === "receive") {
+			const nextReceipt = yield* runtime.executeAgentChannel({
+				...config,
+				command: {
+					...command,
+					operationKey: `${command.operationKey.slice(0, 500)}:replay`
+				}
+			});
+			if (first.kind !== "receive" || nextReceipt.kind !== "receive" || !Schema.toEquivalence(Schema.Array(EventV2))(first.events, nextReceipt.events)) return yield* new ConformanceError({
+				command: kind,
+				rule: "stable_events"
+			});
+		}
+	}
+}, Effect.scoped);
+//#endregion
+export { AgentChannelConformance_exports as AgentChannelConformance, AgentChannelConformance_exports, ConformanceError, Fixture, run };
+
+//# sourceMappingURL=AgentChannelConformance.js.map

package/dist/AgentChannelConformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChannelConformance.js","names":["AgentChannel.commandSchema","AgentChannel.commandSchemaV2","AgentChannel.Key","DualRuntime.Service","AgentChannel.EventV2"],"sources":["../src/AgentChannelConformance.ts"],"sourcesContent":["/** Public replay conformance suite for channel plugins, runnable with @effect/vitest. */\nimport { Effect, Schema } from \"effect\";\n\nimport * as AgentChannel from \"./AgentChannel.ts\";\nimport * as DualRuntime from \"./DualRuntime.ts\";\n\n// Either protocol: the runtime checks each command against the Channel's own protocol.\nconst Command = Schema.Union([\n  AgentChannel.commandSchema(Schema.Json),\n  AgentChannel.commandSchemaV2(Schema.Json),\n]);\nexport const Fixture = Schema.Struct({\n  activate: Command,\n  channelId: AgentChannel.Key,\n  connectionId: Schema.optionalKey(AgentChannel.Key),\n  deactivate: Command,\n  definitionSettings: Schema.Json,\n  deliver: Command,\n  deploymentSettings: Schema.Json,\n  receive: Command,\n});\nexport type Fixture = typeof Fixture.Type;\nexport class ConformanceError extends Schema.TaggedError<ConformanceError>()(\n  \"AgentChannelConformanceError\",\n  {\n    command: Schema.Literals([\"activate\", \"deactivate\", \"receive\", \"deliver\"]),\n    rule: Schema.Literals([\"command_kind\", \"stable_result\", \"stable_events\", \"boundary_rejection\"]),\n  },\n) {}\n\n/**\n * Replays operations that providers declare safe to replay. At-most-once delivery executes once;\n * the durable host owns its replay prohibition. Use an isolated provider test installation: this\n * suite performs provider effects. The host supplies stable keys; the plugin must recover the same\n * external subscription and emit the same provider event keys, even for a fresh receipt key.\n * Boundary rejection and feature/auth matrices are covered by the SDK's public runtime tests.\n */\nexport const run = Effect.fn(\"AgentChannelConformance.run\")(function* (input: Fixture) {\n  const fixture = yield* Schema.decodeUnknownEffect(Fixture)(input, { onExcessProperty: \"error\" });\n  const runtime = yield* DualRuntime.Service;\n  const definition = yield* runtime.getAgentChannel({ channelId: fixture.channelId });\n  const { activate, receive, deliver, deactivate, ...config } = fixture;\n  const { connectionId: _connectionId, ...withoutConnection } = config;\n  const probes = [\n    { code: \"invalid_input\", input: { ...config, channelId: \"\", command: activate } },\n    {\n      // Invocation keys allow '/', but authored identifiers forbid it, so this cannot activate.\n      input: { ...config, channelId: \"conformance/missing/channel\", command: activate },\n      code: \"not_found\",\n    },\n    { code: \"invalid_input\", input: { ...config, command: { ...activate, operationKey: \"\" } } },\n    {\n      code: \"invalid_input\",\n      input: { ...config, agent: { id: \"synthetic-authority\" }, command: activate },\n    },\n    {\n      code: \"invalid_auth\",\n      input:\n        definition.authMethods.length === 0\n          ? { ...config, command: activate, connectionId: \"unexpected\" }\n          : { ...withoutConnection, command: activate },\n    },\n  ];\n  for (const probe of probes) {\n    const outcome = yield* Effect.suspend(() => runtime.executeAgentChannel(probe.input)).pipe(\n      Effect.result,\n    );\n    if (outcome._tag !== \"Failure\" || outcome.failure.code !== probe.code) {\n      return yield* new ConformanceError({ command: \"activate\", rule: \"boundary_rejection\" });\n    }\n  }\n  const commands = [\n    [\"activate\", activate],\n    [\"receive\", receive],\n    [\"deliver\", deliver],\n    [\"deactivate\", deactivate],\n  ] as const;\n  for (const [kind, command] of commands) {\n    if (command.kind !== kind) {\n      return yield* new ConformanceError({ command: kind, rule: \"command_kind\" });\n    }\n  }\n  const activated = yield* Effect.acquireRelease(\n    runtime.executeAgentChannel({ ...config, command: activate }),\n    result =>\n      runtime\n        .executeAgentChannel({\n          ...config,\n          command: {\n            ...deactivate,\n            ...(result.kind === \"activate\"\n              ? { installationKey: result.installationKey, state: result.state }\n              : {}),\n          },\n        })\n        .pipe(Effect.orDie),\n  );\n  for (const [kind, command] of commands) {\n    const first =\n      kind === \"activate\" ? activated : yield* runtime.executeAgentChannel({ ...config, command });\n    if (kind === \"deliver\" && definition.features.deliveryMode === \"at-most-once\") continue;\n    const second = yield* runtime.executeAgentChannel({ ...config, command });\n    const firstJson = yield* Schema.decodeUnknownEffect(Schema.Json)(first);\n    const secondJson = yield* Schema.decodeUnknownEffect(Schema.Json)(second);\n    if (!Schema.toEquivalence(Schema.Json)(firstJson, secondJson)) {\n      return yield* new ConformanceError({ command: kind, rule: \"stable_result\" });\n    }\n    if (kind === \"receive\") {\n      const nextReceipt = yield* runtime.executeAgentChannel({\n        ...config,\n        command: { ...command, operationKey: `${command.operationKey.slice(0, 500)}:replay` },\n      });\n      if (\n        first.kind !== \"receive\" ||\n        nextReceipt.kind !== \"receive\" ||\n        !Schema.toEquivalence(Schema.Array(AgentChannel.EventV2))(first.events, nextReceipt.events)\n      ) {\n        return yield* new ConformanceError({ command: kind, rule: \"stable_events\" });\n      }\n    }\n  }\n}, Effect.scoped);\n\nexport * as AgentChannelConformance from \"./AgentChannelConformance.ts\";\n"],"mappings":"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"}

package/dist/AgentChannelRuntime.d.ts

@@ -0,0 +1,78 @@
+import { AccessOutcome, Any, ChannelError, CheckedResult, Definition, Handler } from "./AgentChannel.js";
+import { Service as Service$1 } from "./ConnectionResolver.js";
+import { AuthResolutionRequirements } from "./internal/auth-execution.js";
+import { Any as Any$1 } from "./Plugin.js";
+import "./AgentChannelRuntime.js";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace AgentChannelRuntime_d_exports {
+  export { AgentChannelRuntime_d_exports as AgentChannelRuntime, ConnectionContext, Input, Interface, Pin, Requirements, Service, layer };
+}
+/** Host-only connection authority context. It is never included in handler inputs. */
+export declare const ConnectionContext: Schema.Struct<{
+  readonly actor: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"user">;
+    readonly userId: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"system">;
+    readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+  }>]>>;
+  readonly source: Schema.optionalKey<Schema.Struct<{
+    readonly kind: Schema.NonEmptyString;
+    readonly subjectId: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>;
+  readonly tenant: Schema.optionalKey<Schema.Struct<{
+    readonly organizationId: Schema.NonEmptyString;
+    readonly teamId: Schema.NonEmptyString;
+  }>>;
+}>;
+declare const Pin: Schema.Struct<{
+  readonly channelId: Schema.NonEmptyString;
+}>;
+declare const Input: Schema.Struct<{
+  readonly channelId: Schema.NonEmptyString;
+  readonly command: Schema.Unknown;
+  readonly connectionId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly context: Schema.optionalKey<Schema.Struct<{
+    readonly actor: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"user">;
+      readonly userId: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"system">;
+      readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+    }>]>>;
+    readonly source: Schema.optionalKey<Schema.Struct<{
+      readonly kind: Schema.NonEmptyString;
+      readonly subjectId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>>;
+    readonly tenant: Schema.optionalKey<Schema.Struct<{
+      readonly organizationId: Schema.NonEmptyString;
+      readonly teamId: Schema.NonEmptyString;
+    }>>;
+  }>>;
+  readonly definitionSettings: Schema.Unknown;
+  readonly deploymentSettings: Schema.Unknown;
+}>;
+type Pin = typeof Pin.Type;
+type Input = typeof Input.Type;
+export interface Interface {
+  /** Reauthorize an already verified identity; does not verify a transport or execute provider operations. */
+  readonly checkAccess: (input: unknown) => Effect.Effect<AccessOutcome, ChannelError>;
+  readonly get: (pin: unknown) => Effect.Effect<Definition, ChannelError>;
+  readonly decodeDefinitionSettings: (input: unknown) => Effect.Effect<Schema.Json, ChannelError>;
+  readonly decodeDeploymentSettings: (input: unknown) => Effect.Effect<Schema.Json, ChannelError>;
+  readonly execute: (input: unknown) => Effect.Effect<CheckedResult, ChannelError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dual-os/sdk/AgentChannelRuntime", Interface>;
+export declare class Service extends Service_base {}
+type Definitions<P extends Any$1> = P["agentChannels"][number]["definition"];
+type ChannelHandlers<P extends Any$1, C> = C extends Any ? Handler<`${P["identifier"]}/${C["identifier"]}`> : never;
+type PluginHandlers<P> = P extends Any$1 ? ChannelHandlers<P, P["agentChannels"][number]> : never;
+type ExtensionRequirements<D> = D extends {
+  readonly extensions: infer Extensions extends Readonly<Record<string, Schema.Top>>;
+} ? Extensions[keyof Extensions]["DecodingServices"] | Extensions[keyof Extensions]["EncodingServices"] : never;
+export type Requirements<P extends Any$1> = PluginHandlers<P> | ExtensionRequirements<Definitions<P>> | Definitions<P>["definitionSettings"]["DecodingServices"] | Definitions<P>["deploymentSettings"]["DecodingServices"] | Definitions<P>["state"]["DecodingServices"] | Definitions<P>["state"]["EncodingServices"] | AuthResolutionRequirements<Definitions<P>["authMethods"]> | (Definitions<P>["authMethods"][number] extends never ? never : Service$1);
+/** Build from the installed plugins. */
+export declare const layer: <P extends Any$1>(plugins: readonly P[]) => Layer.Layer<Service, never, Requirements<P>>;
+//#endregion
+export { AgentChannelRuntime_d_exports as AgentChannelRuntime, AgentChannelRuntime_d_exports, Input, Pin };
+//# sourceMappingURL=AgentChannelRuntime.d.ts.map

package/dist/AgentChannelRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChannelRuntime.d.ts","names":["AgentChannel.AccessOutcome","AgentChannel.ChannelError","AgentChannel.Definition","AgentChannel.CheckedResult","Plugin.Any","AgentChannel.Any","AgentChannel.Handler","ConnectionResolver.Service"],"sources":["../src/AgentChannelRuntime.ts"],"mappings":";;;;;;;;;;qBAUa,mBAAiB,OAAA;;;;;;;;;;;;;;;;;cAiBxB,KAAG,OAAA;;;cACH,OAAK,OAAA;;;;;;;;;;;;;;;;;;;;;;;;KAgBC,aAAa,IAAI;KACjB,eAAe,MAAM;iBAChB;;WAEN,cACP,mBACG,OAAO,OAAOA,eAA4BC;WACtC,MAAM,iBAAiB,OAAO,OAAOC,YAAyBD;WAC9D,2BACP,mBACG,OAAO,OAAO,OAAO,MAAMA;WACvB,2BACP,mBACG,OAAO,OAAO,OAAO,MAAMA;WACvB,UACP,mBACG,OAAO,OAAOE,eAA4BF;;;qBAEpC,gBAAgB;KAIxB,YAAY,UAAUG,SAAc;KACpC,gBAAgB,UAAUA,OAAY,KAAK,UAAUC,MACtDC,WAAwB,mBAAmB;KAE1C,eAAe,KAAK,UAAUF,QAC/B,gBAAgB,GAAG;KAElB,sBAAsB,KAAK;WACrB,kBAAkB,mBAAmB,SAAS,eAAe,OAAO;IAGvE,iBAAiB,kCACjB,iBAAiB;YAEb,aAAa,UAAUA,SAC/B,eAAe,KACf,sBAAsB,YAAY,MAClC,YAAY,+CACZ,YAAY,+CACZ,YAAY,kCACZ,YAAY,kCACZ,2BAA2B,YAAY,sBACtC,YAAY,kDAAkDG;;qBAyMtD,QAAS,UAAUH,OAAU,kBACtB,QACjB,MAAM,MAAM,gBAAgB,aAAa"}

package/dist/AgentChannelRuntime.js

@@ -0,0 +1,270 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { AccessOutcome, ChannelError, CheckedResult, FailureCode, Key, Verification, VerifiedIdentity, handlerKey, schemasFor, validateDefinition } from "./AgentChannel.js";
+import { Service as Service$1 } from "./ConnectionResolver.js";
+import { findHandler } from "./internal/handler-context.js";
+import "./AgentChannelRuntime.js";
+import { Cause, Context, Effect, Layer, Option, Predicate, Schema } from "effect";
+//#region src/AgentChannelRuntime.ts
+/** Checked execution of pinned Agent Channel capabilities. No product lifecycle or persistence. */
+var AgentChannelRuntime_exports = /* @__PURE__ */ __exportAll({
+	AgentChannelRuntime: () => AgentChannelRuntime_exports,
+	ConnectionContext: () => ConnectionContext,
+	Service: () => Service,
+	layer: () => layer
+});
+/** Host-only connection authority context. It is never included in handler inputs. */
+const ConnectionContext = Schema.Struct({
+	actor: Schema.optionalKey(Schema.Union([Schema.Struct({
+		kind: Schema.Literal("user"),
+		userId: Key
+	}), Schema.Struct({
+		kind: Schema.Literal("system"),
+		reason: Schema.optionalKey(Key)
+	})])),
+	source: Schema.optionalKey(Schema.Struct({
+		kind: Key,
+		subjectId: Schema.optionalKey(Key)
+	})),
+	tenant: Schema.optionalKey(Schema.Struct({
+		organizationId: Key,
+		teamId: Key
+	}))
+});
+const Pin = Schema.Struct({ channelId: Key });
+const Input = Schema.Struct({
+	...Pin.fields,
+	command: Schema.Unknown,
+	connectionId: Schema.optionalKey(Key),
+	context: Schema.optionalKey(ConnectionContext),
+	definitionSettings: Schema.Unknown,
+	deploymentSettings: Schema.Unknown
+});
+const AccessInput = Schema.Struct({
+	...Pin.fields,
+	connectionId: Schema.optionalKey(Key),
+	context: Schema.optionalKey(ConnectionContext),
+	definitionSettings: Schema.Unknown,
+	deploymentSettings: Schema.Unknown,
+	identity: VerifiedIdentity
+});
+var Service = class extends Context.Service()("@dual-os/sdk/AgentChannelRuntime") {};
+const fail = (code) => new ChannelError({ code });
+const safe = (effect, code) => effect.pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.fail(fail(code))));
+const AssetResultJson = Schema.Json.check(Schema.makeFilter((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 14680064));
+const Json = Schema.Json.check(Schema.makeFilter((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 2097152));
+const strict = { onExcessProperty: "error" };
+const decode = (schema, input, code) => safe(Effect.suspend(() => Schema.decodeUnknownEffect(schema)(input, strict)), code);
+const json = (value, code) => decode(Json, value, code);
+const decodeData = Effect.fn("AgentChannelRuntime.decodeData")(function* (schema, input, code, largeAssetResult = false) {
+	const boundary = largeAssetResult ? AssetResultJson : Json;
+	yield* decode(boundary, input, code);
+	const value = yield* decode(schema, input, code);
+	yield* decode(boundary, value, code);
+	return value;
+});
+const invokeHandler = (handler, effect) => effect.pipe(Effect.provideContext(handler.context), Effect.catch((error) => decode(Schema.TaggedStruct("AgentChannelHandlerError", { code: FailureCode }), Predicate.isObject(error) ? { ...error } : error, "provider_failure").pipe(Effect.flatMap((checked) => Effect.fail(new ChannelError({
+	code: "provider_failure",
+	providerCode: checked.code
+}))))), Effect.catchCause((cause) => {
+	if (Cause.hasInterrupts(cause)) return Effect.interrupt;
+	const error = Cause.findErrorOption(cause);
+	return Option.isSome(error) && error.value instanceof ChannelError ? Effect.fail(error.value) : Effect.fail(fail("provider_failure"));
+}));
+const checkExtensions = Effect.fn("AgentChannelRuntime.checkExtensions")(function* (definition, extensions, code) {
+	for (const [key, value] of Object.entries(extensions ?? {})) {
+		const schema = definition.extensions?.[key];
+		if (schema === void 0) return yield* fail(code);
+		yield* decodeData(Schema.toType(schema), value, code);
+	}
+});
+const checkMessage = (features, destination, content) => (destination.kind === "direct" || features.groups) && (destination.threadKey === void 0 || features.threads) && (content.mentions === void 0 || features.mentions) && (content.assets === void 0 || features.assets) && (content.replyToMessageKey === void 0 || features.replies);
+const checkDelivery = (features, command) => "content" in command ? checkMessage(features, command.destination, command.content) : checkMessage(features, command.destination, { text: "" }) && (features.operations ?? []).includes(command.operation.kind);
+const Material = Schema.Struct({
+	connectionId: Key,
+	encoding: Schema.optionalKey(Schema.Literal("json")),
+	material: Schema.Unknown,
+	methodId: Key,
+	providerId: Key,
+	setup: Schema.Unknown
+});
+const ResolveHook = Schema.declare((value) => Predicate.isFunction(value));
+const resolveAuth = Effect.fn("AgentChannelRuntime.resolveAuth")(function* (providerId, channelId, definition, connectionId, phase, context) {
+	if (definition.authMethods.length === 0) {
+		if (connectionId !== void 0) return yield* fail("invalid_auth");
+		return;
+	}
+	if (connectionId === void 0) return yield* fail("invalid_auth");
+	const resolver = yield* Effect.serviceOption(Service$1);
+	if (Option.isNone(resolver)) return yield* fail("invalid_auth");
+	const raw = yield* safe(Effect.suspend(() => resolver.value.resolve({
+		connectionId,
+		target: {
+			phase,
+			providerId,
+			targetId: channelId,
+			targetKind: "agent-channel"
+		},
+		...context === void 0 ? {} : { context }
+	})), "invalid_auth");
+	const resolved = yield* decode(Material, raw, "invalid_auth");
+	if (resolved.providerId !== providerId || resolved.connectionId !== connectionId) return yield* fail("invalid_auth");
+	const method = definition.authMethods.find((method) => resolved.methodId === method.identifier || resolved.methodId === `${providerId}/${method.identifier}`);
+	if (method === void 0) return yield* fail("invalid_auth");
+	const decodeAuth = (schema, value) => decode(resolved.encoding === "json" ? Schema.toCodecJson(schema) : schema, value, "invalid_auth");
+	const setup = method.setup === void 0 ? yield* decode(Schema.Undefined, resolved.setup, "invalid_auth") : yield* decodeAuth(method.setup, resolved.setup);
+	const material = yield* decodeAuth(method.material, resolved.material);
+	let value;
+	if (method.resolve === void 0) value = method.material === method.value ? material : yield* decode(method.value, material, "invalid_auth");
+	else {
+		const hook = yield* decode(ResolveHook, method.resolve, "invalid_auth");
+		const output = yield* safe(Effect.suspend(() => {
+			const result = hook(material, { setup });
+			return Effect.isEffect(result) ? result : Effect.succeed(result);
+		}), "invalid_auth");
+		value = yield* decode(method.value, output, "invalid_auth");
+	}
+	return {
+		methodId: method.identifier,
+		value
+	};
+});
+const find = (plugins, pin) => {
+	for (const provider of plugins) {
+		const channel = provider.agentChannels.find((channel) => `${provider.identifier}/${channel.identifier}` === pin.channelId);
+		if (channel !== void 0) return {
+			definition: channel.definition,
+			provider
+		};
+	}
+};
+/** Build from the installed plugins. */
+const layer = (plugins) => Layer.effect(Service, Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const get = Effect.fn("AgentChannelRuntime.get")(function* (input) {
+		const pin = yield* decode(Pin, input, "invalid_input");
+		const found = find(plugins, pin);
+		if (found === void 0) return yield* fail("not_found");
+		yield* safe(Effect.sync(() => {
+			validateDefinition(found.definition, found.provider.identifier, found.provider.authMethods);
+		}), "invalid_definition");
+		const handler = Option.fromNullishOr(findHandler(context, found.provider.identifier, handlerKey(pin.channelId)));
+		if (Option.isNone(handler) || !Predicate.isObject(handler.value.runtime) || !Predicate.isFunction(handler.value.runtime.execute) || !Predicate.isFunction(handler.value.runtime.verify) || !Predicate.isFunction(handler.value.runtime.checkAccess)) return yield* fail("handler_unavailable");
+		return found.definition;
+	});
+	const checkAccess = Effect.fn("AgentChannelRuntime.checkAccess")(function* (input) {
+		yield* json(input, "invalid_input");
+		const request = yield* decode(AccessInput, input, "invalid_input");
+		const definition = yield* get({ channelId: request.channelId });
+		const found = find(plugins, request);
+		if (found === void 0) return yield* fail("not_found");
+		const definitionSettings = yield* decodeData(definition.definitionSettings, request.definitionSettings, "invalid_input");
+		const deploymentSettings = yield* decodeData(definition.deploymentSettings, request.deploymentSettings, "invalid_input");
+		if (!checkMessage(definition.features, request.identity.conversation, { text: "" })) return yield* fail("unsupported_feature");
+		const auth = yield* resolveAuth(found.provider.identifier, request.channelId, definition, request.connectionId, "check_access", request.context);
+		const handler = Option.fromNullishOr(findHandler(context, found.provider.identifier, handlerKey(request.channelId)));
+		if (Option.isNone(handler)) return yield* fail("handler_unavailable");
+		const output = yield* invokeHandler(handler.value, Effect.suspend(() => handler.value.runtime.checkAccess(request.identity, {
+			definitionSettings,
+			deploymentSettings,
+			...auth === void 0 ? {} : { auth }
+		})));
+		return yield* decodeData(AccessOutcome, output, "invalid_result");
+	});
+	const execute = Effect.fn("AgentChannelRuntime.execute")(function* (input) {
+		yield* json(input, "invalid_input");
+		const request = yield* decode(Input, input, "invalid_input");
+		const definition = yield* get({ channelId: request.channelId });
+		const found = find(plugins, request);
+		if (found === void 0) return yield* fail("not_found");
+		const definitionSettings = yield* decodeData(definition.definitionSettings, request.definitionSettings, "invalid_input");
+		const deploymentSettings = yield* decodeData(definition.deploymentSettings, request.deploymentSettings, "invalid_input");
+		const schemas = schemasFor(definition);
+		const command = yield* decodeData(schemas.command, request.command, "invalid_input");
+		yield* checkExtensions(definition, command.extensions, "invalid_input");
+		if (command.kind === "deliver" && command.operationKey !== command.deliveryKey) return yield* fail("invalid_input");
+		if (command.kind === "deliver" && !checkDelivery(definition.features, command)) return yield* fail("unsupported_feature");
+		if (command.kind === "deliver" && "operation" in command && command.operation.kind === "set_reaction" && command.operation.target.kind === "activation" && command.activationMessageKey === void 0) return yield* fail("invalid_input");
+		if (command.kind === "read_context" && (definition.features.readContext !== true || !checkMessage(definition.features, command.destination, { text: "" }))) return yield* fail("unsupported_feature");
+		const handler = Option.fromNullishOr(findHandler(context, found.provider.identifier, handlerKey(request.channelId)));
+		if (Option.isNone(handler)) return yield* fail("handler_unavailable");
+		const auth = yield* resolveAuth(found.provider.identifier, request.channelId, definition, request.connectionId, command.kind, request.context);
+		const operationKey = command.operationKey;
+		const kind = command.kind;
+		const deliveryKey = command.kind === "deliver" ? command.deliveryKey : void 0;
+		const assetKey = command.kind === "read_asset" ? command.asset.assetKey : void 0;
+		const adapterContext = {
+			definitionSettings,
+			deploymentSettings,
+			...auth === void 0 ? {} : { auth }
+		};
+		if (!Predicate.isFunction(handler.value.runtime.execute) || !Predicate.isFunction(handler.value.runtime.verify) || !Predicate.isFunction(handler.value.runtime.checkAccess)) return yield* fail("handler_unavailable");
+		if (command.kind === "receive") yield* decodeData(Verification, yield* invokeHandler(handler.value, Effect.suspend(() => handler.value.runtime.verify(command.request, adapterContext))), "invalid_result");
+		if (command.kind === "read_asset") {
+			if (!definition.features.assets) return yield* fail("unsupported_feature");
+			if ((yield* decodeData(AccessOutcome, yield* invokeHandler(handler.value, Effect.suspend(() => handler.value.runtime.checkAccess(command.identity, adapterContext))), "invalid_result")).decision !== "allow") return yield* new ChannelError({
+				code: "provider_failure",
+				providerCode: "unauthorized"
+			});
+		}
+		const output = yield* invokeHandler(handler.value, Effect.suspend(() => handler.value.runtime.execute(command, adapterContext)));
+		const result = yield* decodeData(schemas.typeResult, output, "invalid_result", kind === "read_asset");
+		if (result.kind !== kind || result.operationKey !== operationKey || result.kind === "deliver" && result.deliveryKey !== deliveryKey || result.kind === "read_asset" && result.assetKey !== assetKey) return yield* fail("invalid_result");
+		yield* checkExtensions(definition, result.extensions, "invalid_result");
+		if (result.kind === "deliver" && result.status === "pending" && !definition.features.deliveryState) return yield* fail("invalid_result");
+		const allowedEvents = [];
+		const deniedEventKeys = [];
+		if (result.kind === "receive") {
+			if (result.deniedEventKeys !== void 0) return yield* fail("invalid_result");
+			if (result.activationProof === "verified" && (result.response === void 0 || result.events.length !== 0)) return yield* fail("invalid_result");
+			const eventKeys = /* @__PURE__ */ new Set();
+			for (const event of result.events) {
+				if (eventKeys.has(event.eventKey)) return yield* fail("invalid_result");
+				eventKeys.add(event.eventKey);
+				if (event.kind === "message" && !checkMessage(definition.features, event.conversation, event.content)) return yield* fail("invalid_result");
+				if ((event.kind === "echo" || event.kind === "stop") && !checkMessage(definition.features, event.conversation, { text: "" })) return yield* fail("invalid_result");
+				if (event.kind === "delivery_update" && !definition.features.deliveryState) return yield* fail("invalid_result");
+				yield* checkExtensions(definition, event.extensions, "invalid_result");
+				let denied = false;
+				if (event.kind === "message" || event.kind === "echo" || event.kind === "stop") {
+					const identity = yield* decodeData(VerifiedIdentity, {
+						conversation: event.conversation,
+						senderKey: event.senderKey
+					}, "invalid_result");
+					denied = (yield* decodeData(AccessOutcome, yield* invokeHandler(handler.value, Effect.suspend(() => handler.value.runtime.checkAccess(identity, adapterContext))), "invalid_result")).decision === "deny";
+				}
+				if (denied) {
+					deniedEventKeys.push(event.eventKey);
+					continue;
+				}
+				allowedEvents.push(event);
+			}
+		}
+		const encoded = yield* safe(Schema.encodeUnknownEffect(schemas.result)(result.kind === "receive" ? {
+			...result,
+			events: allowedEvents,
+			...deniedEventKeys.length === 0 ? {} : { deniedEventKeys }
+		} : result, strict), "invalid_result");
+		return yield* decodeData(CheckedResult, encoded, "invalid_result", kind === "read_asset");
+	});
+	const run = (effect) => effect.pipe(Effect.provideContext(context));
+	const decodeSettings = (field) => Effect.fn("AgentChannelRuntime.decodeSettings")(function* (input) {
+		const request = yield* decode(Schema.Struct({
+			...Pin.fields,
+			value: Schema.Json
+		}), input, "invalid_input");
+		const schema = (yield* get({ channelId: request.channelId }))[field];
+		const value = yield* decodeData(schema, request.value, "invalid_input");
+		return yield* json(yield* safe(Schema.encodeUnknownEffect(schema)(value, strict), "invalid_input"), "invalid_input");
+	});
+	return Service.of({
+		checkAccess: (input) => run(checkAccess(input)),
+		decodeDefinitionSettings: (input) => run(decodeSettings("definitionSettings")(input)),
+		decodeDeploymentSettings: (input) => run(decodeSettings("deploymentSettings")(input)),
+		execute: (input) => run(execute(input)),
+		get: (input) => run(get(input))
+	});
+}));
+//#endregion
+export { AgentChannelRuntime_exports as AgentChannelRuntime, AgentChannelRuntime_exports, ConnectionContext, Service, layer };
+
+//# sourceMappingURL=AgentChannelRuntime.js.map

package/dist/AgentChannelRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChannelRuntime.js","names":["AgentChannel.Key","AgentChannel.VerifiedIdentity","AgentChannel.ChannelError","AgentChannel.FailureCode","ConnectionResolver.Service","AgentChannel.handlerKey","AgentChannel.AccessOutcome","AgentChannel.schemasFor","AgentChannel.Verification","AgentChannel.CheckedResult"],"sources":["../src/AgentChannelRuntime.ts"],"sourcesContent":["/** Checked execution of pinned Agent Channel capabilities. No product lifecycle or persistence. */\nimport { Cause, Context, Effect, Layer, Option, Predicate, Schema } from \"effect\";\n\nimport * as AgentChannel from \"./AgentChannel.ts\";\nimport { ConnectionResolver } from \"./ConnectionResolver.ts\";\nimport type { AuthResolutionRequirements } from \"./internal/auth-execution.ts\";\nimport { findHandler } from \"./internal/handler-context.ts\";\nimport type * as Plugin from \"./Plugin.ts\";\n\n/** Host-only connection authority context. It is never included in handler inputs. */\nexport const ConnectionContext = Schema.Struct({\n  actor: Schema.optionalKey(\n    Schema.Union([\n      Schema.Struct({ kind: Schema.Literal(\"user\"), userId: AgentChannel.Key }),\n      Schema.Struct({\n        kind: Schema.Literal(\"system\"),\n        reason: Schema.optionalKey(AgentChannel.Key),\n      }),\n    ]),\n  ),\n  source: Schema.optionalKey(\n    Schema.Struct({ kind: AgentChannel.Key, subjectId: Schema.optionalKey(AgentChannel.Key) }),\n  ),\n  tenant: Schema.optionalKey(\n    Schema.Struct({ organizationId: AgentChannel.Key, teamId: AgentChannel.Key }),\n  ),\n});\nconst Pin = Schema.Struct({ channelId: AgentChannel.Key });\nconst Input = Schema.Struct({\n  ...Pin.fields,\n  command: Schema.Unknown,\n  connectionId: Schema.optionalKey(AgentChannel.Key),\n  context: Schema.optionalKey(ConnectionContext),\n  definitionSettings: Schema.Unknown,\n  deploymentSettings: Schema.Unknown,\n});\nconst AccessInput = Schema.Struct({\n  ...Pin.fields,\n  connectionId: Schema.optionalKey(AgentChannel.Key),\n  context: Schema.optionalKey(ConnectionContext),\n  definitionSettings: Schema.Unknown,\n  deploymentSettings: Schema.Unknown,\n  identity: AgentChannel.VerifiedIdentity,\n});\nexport type Pin = typeof Pin.Type;\nexport type Input = typeof Input.Type;\nexport interface Interface {\n  /** Reauthorize an already verified identity; does not verify a transport or execute provider operations. */\n  readonly checkAccess: (\n    input: unknown,\n  ) => Effect.Effect<AgentChannel.AccessOutcome, AgentChannel.ChannelError>;\n  readonly get: (pin: unknown) => Effect.Effect<AgentChannel.Definition, AgentChannel.ChannelError>;\n  readonly decodeDefinitionSettings: (\n    input: unknown,\n  ) => Effect.Effect<Schema.Json, AgentChannel.ChannelError>;\n  readonly decodeDeploymentSettings: (\n    input: unknown,\n  ) => Effect.Effect<Schema.Json, AgentChannel.ChannelError>;\n  readonly execute: (\n    input: unknown,\n  ) => Effect.Effect<AgentChannel.CheckedResult, AgentChannel.ChannelError>;\n}\nexport class Service extends Context.Service<Service, Interface>()(\n  \"@dual-os/sdk/AgentChannelRuntime\",\n) {}\n\ntype Definitions<P extends Plugin.Any> = P[\"agentChannels\"][number][\"definition\"];\ntype ChannelHandlers<P extends Plugin.Any, C> = C extends AgentChannel.Any\n  ? AgentChannel.Handler<`${P[\"identifier\"]}/${C[\"identifier\"]}`>\n  : never;\ntype PluginHandlers<P> = P extends Plugin.Any\n  ? ChannelHandlers<P, P[\"agentChannels\"][number]>\n  : never;\ntype ExtensionRequirements<D> = D extends {\n  readonly extensions: infer Extensions extends Readonly<Record<string, Schema.Top>>;\n}\n  ?\n      | Extensions[keyof Extensions][\"DecodingServices\"]\n      | Extensions[keyof Extensions][\"EncodingServices\"]\n  : never;\nexport type Requirements<P extends Plugin.Any> =\n  | PluginHandlers<P>\n  | ExtensionRequirements<Definitions<P>>\n  | Definitions<P>[\"definitionSettings\"][\"DecodingServices\"]\n  | Definitions<P>[\"deploymentSettings\"][\"DecodingServices\"]\n  | Definitions<P>[\"state\"][\"DecodingServices\"]\n  | Definitions<P>[\"state\"][\"EncodingServices\"]\n  | AuthResolutionRequirements<Definitions<P>[\"authMethods\"]>\n  | (Definitions<P>[\"authMethods\"][number] extends never ? never : ConnectionResolver.Service);\n\nconst fail = (code: typeof AgentChannel.ErrorCode.Type) => new AgentChannel.ChannelError({ code });\nconst safe = <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  code: typeof AgentChannel.ErrorCode.Type,\n): Effect.Effect<A, AgentChannel.ChannelError, R> =>\n  effect.pipe(\n    Effect.catchCause(cause =>\n      Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.fail(fail(code)),\n    ),\n  );\nconst AssetResultJson = Schema.Json.check(\n  Schema.makeFilter(\n    value => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 14_680_064,\n  ),\n);\nconst Json = Schema.Json.check(\n  Schema.makeFilter(\n    value => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 2_097_152,\n  ),\n);\nconst strict = { onExcessProperty: \"error\" } as const;\nconst decode = <S extends Schema.Top>(\n  schema: S,\n  input: unknown,\n  code: typeof AgentChannel.ErrorCode.Type,\n) =>\n  safe(\n    Effect.suspend(() => Schema.decodeUnknownEffect(schema)(input, strict)),\n    code,\n  );\nconst json = (value: unknown, code: typeof AgentChannel.ErrorCode.Type) =>\n  decode(Json, value, code);\nconst decodeData = Effect.fn(\"AgentChannelRuntime.decodeData\")(function* <S extends Schema.Top>(\n  schema: S,\n  input: unknown,\n  code: typeof AgentChannel.ErrorCode.Type,\n  largeAssetResult = false,\n) {\n  const boundary = largeAssetResult ? AssetResultJson : Json;\n  yield* decode(boundary, input, code);\n  const value = yield* decode(schema, input, code);\n  yield* decode(boundary, value, code);\n  return value;\n});\n\nconst invokeHandler = (\n  handler: AgentChannel.Handler,\n  effect: Effect.Effect<unknown, unknown, unknown>,\n) =>\n  effect.pipe(\n    Effect.provideContext(handler.context),\n    Effect.catch(error =>\n      decode(\n        Schema.TaggedStruct(\"AgentChannelHandlerError\", { code: AgentChannel.FailureCode }),\n        Predicate.isObject(error) ? { ...error } : error,\n        \"provider_failure\",\n      ).pipe(\n        Effect.flatMap(checked =>\n          Effect.fail(\n            new AgentChannel.ChannelError({ code: \"provider_failure\", providerCode: checked.code }),\n          ),\n        ),\n      ),\n    ),\n    Effect.catchCause(cause => {\n      if (Cause.hasInterrupts(cause)) return Effect.interrupt;\n      const error = Cause.findErrorOption(cause);\n      return Option.isSome(error) && error.value instanceof AgentChannel.ChannelError\n        ? Effect.fail(error.value)\n        : Effect.fail(fail(\"provider_failure\"));\n    }),\n  );\n\nconst checkExtensions = Effect.fn(\"AgentChannelRuntime.checkExtensions\")(function* (\n  definition: AgentChannel.Definition,\n  extensions: Readonly<Record<string, Schema.Json>> | undefined,\n  code: typeof AgentChannel.ErrorCode.Type,\n) {\n  for (const [key, value] of Object.entries(extensions ?? {})) {\n    const schema = definition.extensions?.[key];\n    if (schema === undefined) return yield* fail(code);\n    // Extensions are checked values, not a provider payload escape hatch. No normalization.\n    yield* decodeData(Schema.toType(schema), value, code);\n  }\n});\nconst checkMessage = (\n  features: AgentChannel.Features,\n  destination: AgentChannel.Destination,\n  content: AgentChannel.Content,\n): boolean =>\n  (destination.kind === \"direct\" || features.groups) &&\n  (destination.threadKey === undefined || features.threads) &&\n  (content.mentions === undefined || features.mentions) &&\n  (content.assets === undefined || features.assets) &&\n  (content.replyToMessageKey === undefined || features.replies);\n\nconst checkDelivery = (\n  features: AgentChannel.Features,\n  command: Extract<AgentChannel.Command | AgentChannel.CommandV2, { kind: \"deliver\" }>,\n): boolean =>\n  \"content\" in command\n    ? checkMessage(features, command.destination, command.content)\n    : checkMessage(features, command.destination, { text: \"\" }) &&\n      (features.operations ?? []).includes(command.operation.kind);\n\nconst Material = Schema.Struct({\n  connectionId: AgentChannel.Key,\n  // The plugin worker's resolver marks its JSON-carried material.\n  encoding: Schema.optionalKey(Schema.Literal(\"json\")),\n  material: Schema.Unknown,\n  methodId: AgentChannel.Key,\n  providerId: AgentChannel.Key,\n  setup: Schema.Unknown,\n});\nconst ResolveHook = Schema.declare(\n  (value): value is (material: unknown, context: { readonly setup: unknown }) => unknown =>\n    Predicate.isFunction(value),\n);\nconst resolveAuth = Effect.fn(\"AgentChannelRuntime.resolveAuth\")(function* (\n  providerId: string,\n  channelId: string,\n  definition: AgentChannel.Definition,\n  connectionId: string | undefined,\n  phase: string,\n  context: typeof ConnectionContext.Type | undefined,\n) {\n  if (definition.authMethods.length === 0) {\n    if (connectionId !== undefined) return yield* fail(\"invalid_auth\");\n    return undefined;\n  }\n  // The host alone selects/authorizes the pinned connection. Its records never reach the plugin.\n  if (connectionId === undefined) return yield* fail(\"invalid_auth\");\n  const resolver = yield* Effect.serviceOption(ConnectionResolver.Service);\n  if (Option.isNone(resolver)) return yield* fail(\"invalid_auth\");\n  const raw = yield* safe(\n    Effect.suspend(() =>\n      resolver.value.resolve({\n        connectionId,\n        target: { phase, providerId, targetId: channelId, targetKind: \"agent-channel\" },\n        ...(context === undefined ? {} : { context }),\n      }),\n    ),\n    \"invalid_auth\",\n  );\n  const resolved = yield* decode(Material, raw, \"invalid_auth\");\n  if (resolved.providerId !== providerId || resolved.connectionId !== connectionId) {\n    return yield* fail(\"invalid_auth\");\n  }\n  const method = definition.authMethods.find(\n    method =>\n      resolved.methodId === method.identifier ||\n      resolved.methodId === `${providerId}/${method.identifier}`,\n  );\n  if (method === undefined) return yield* fail(\"invalid_auth\");\n  // Material the worker received as JSON decodes through each schema's JSON codec.\n  const decodeAuth = <S extends Schema.Top>(schema: S, value: unknown) =>\n    decode(\n      resolved.encoding === \"json\" ? Schema.toCodecJson(schema) : schema,\n      value,\n      \"invalid_auth\",\n    );\n  const setup =\n    method.setup === undefined\n      ? yield* decode(Schema.Undefined, resolved.setup, \"invalid_auth\")\n      : yield* decodeAuth(method.setup, resolved.setup);\n  const material = yield* decodeAuth(method.material, resolved.material);\n  let value: unknown;\n  if (method.resolve === undefined) {\n    value =\n      method.material === method.value\n        ? material\n        : yield* decode(method.value, material, \"invalid_auth\");\n  } else {\n    const hook = yield* decode(ResolveHook, method.resolve, \"invalid_auth\");\n    const output = yield* safe(\n      Effect.suspend(() => {\n        const result = hook(material, { setup });\n        return Effect.isEffect(result) ? result : Effect.succeed(result);\n      }),\n      \"invalid_auth\",\n    );\n    value = yield* decode(method.value, output, \"invalid_auth\");\n  }\n  // Schemas may use Redacted for auth. Only this checked value, never material/setup/binding,\n  // is exposed to the command handler.\n  return { methodId: method.identifier, value };\n});\n\nconst find = (plugins: readonly Plugin.Any[], pin: Pin) => {\n  for (const provider of plugins) {\n    const channel = provider.agentChannels.find(\n      channel => `${provider.identifier}/${channel.identifier}` === pin.channelId,\n    );\n    if (channel !== undefined) return { definition: channel.definition, provider };\n  }\n  return undefined;\n};\n\n/** Build from the installed plugins. */\nexport const layer = <P extends Plugin.Any>(\n  plugins: readonly P[],\n): Layer.Layer<Service, never, Requirements<P>> =>\n  Layer.effect(\n    Service,\n    Effect.gen(function* () {\n      const context = yield* Effect.context<Requirements<P>>();\n      const get = Effect.fn(\"AgentChannelRuntime.get\")(function* (input: unknown) {\n        const pin = yield* decode(Pin, input, \"invalid_input\");\n        const found = find(plugins, pin);\n        if (found === undefined) return yield* fail(\"not_found\");\n        yield* safe(\n          Effect.sync(() => {\n            AgentChannel.validateDefinition(\n              found.definition,\n              found.provider.identifier,\n              found.provider.authMethods,\n            );\n          }),\n          \"invalid_definition\",\n        );\n        const handler = Option.fromNullishOr(\n          findHandler(\n            context,\n            found.provider.identifier,\n            AgentChannel.handlerKey(pin.channelId),\n          ) as AgentChannel.Handler | undefined,\n        );\n        if (\n          Option.isNone(handler) ||\n          !Predicate.isObject(handler.value.runtime) ||\n          !Predicate.isFunction(handler.value.runtime.execute) ||\n          !Predicate.isFunction(handler.value.runtime.verify) ||\n          !Predicate.isFunction(handler.value.runtime.checkAccess)\n        ) {\n          return yield* fail(\"handler_unavailable\");\n        }\n        return found.definition;\n      });\n      const checkAccess = Effect.fn(\"AgentChannelRuntime.checkAccess\")(function* (input: unknown) {\n        yield* json(input, \"invalid_input\");\n        const request = yield* decode(AccessInput, input, \"invalid_input\");\n        const definition = yield* get({ channelId: request.channelId });\n        const found = find(plugins, request);\n        if (found === undefined) return yield* fail(\"not_found\");\n        const definitionSettings = yield* decodeData(\n          definition.definitionSettings,\n          request.definitionSettings,\n          \"invalid_input\",\n        );\n        const deploymentSettings = yield* decodeData(\n          definition.deploymentSettings,\n          request.deploymentSettings,\n          \"invalid_input\",\n        );\n        if (!checkMessage(definition.features, request.identity.conversation, { text: \"\" })) {\n          return yield* fail(\"unsupported_feature\");\n        }\n        const auth = yield* resolveAuth(\n          found.provider.identifier,\n          request.channelId,\n          definition,\n          request.connectionId,\n          \"check_access\",\n          request.context,\n        );\n        const handler = Option.fromNullishOr(\n          findHandler(\n            context,\n            found.provider.identifier,\n            AgentChannel.handlerKey(request.channelId),\n          ) as AgentChannel.Handler | undefined,\n        );\n        if (Option.isNone(handler)) return yield* fail(\"handler_unavailable\");\n        const output = yield* invokeHandler(\n          handler.value,\n          Effect.suspend(() =>\n            handler.value.runtime.checkAccess(request.identity, {\n              definitionSettings,\n              deploymentSettings,\n              ...(auth === undefined ? {} : { auth }),\n            }),\n          ),\n        );\n        return yield* decodeData(AgentChannel.AccessOutcome, output, \"invalid_result\");\n      });\n      const execute = Effect.fn(\"AgentChannelRuntime.execute\")(function* (input: unknown) {\n        yield* json(input, \"invalid_input\");\n        const request = yield* decode(Input, input, \"invalid_input\");\n        const definition = yield* get({ channelId: request.channelId });\n        const found = find(plugins, request);\n        if (found === undefined) return yield* fail(\"not_found\");\n        const definitionSettings = yield* decodeData(\n          definition.definitionSettings,\n          request.definitionSettings,\n          \"invalid_input\",\n        );\n        const deploymentSettings = yield* decodeData(\n          definition.deploymentSettings,\n          request.deploymentSettings,\n          \"invalid_input\",\n        );\n        const schemas = AgentChannel.schemasFor(definition);\n        const command: AgentChannel.Command | AgentChannel.CommandV2 = yield* decodeData(\n          schemas.command,\n          request.command,\n          \"invalid_input\",\n        );\n        yield* checkExtensions(definition, command.extensions, \"invalid_input\");\n        if (command.kind === \"deliver\" && command.operationKey !== command.deliveryKey) {\n          return yield* fail(\"invalid_input\");\n        }\n        if (command.kind === \"deliver\" && !checkDelivery(definition.features, command)) {\n          return yield* fail(\"unsupported_feature\");\n        }\n        if (\n          command.kind === \"deliver\" &&\n          \"operation\" in command &&\n          command.operation.kind === \"set_reaction\" &&\n          command.operation.target.kind === \"activation\" &&\n          command.activationMessageKey === undefined\n        ) {\n          return yield* fail(\"invalid_input\");\n        }\n        if (\n          command.kind === \"read_context\" &&\n          (definition.features.readContext !== true ||\n            !checkMessage(definition.features, command.destination, { text: \"\" }))\n        ) {\n          return yield* fail(\"unsupported_feature\");\n        }\n        const handler = Option.fromNullishOr(\n          findHandler(\n            context,\n            found.provider.identifier,\n            AgentChannel.handlerKey(request.channelId),\n          ) as AgentChannel.Handler | undefined,\n        );\n        if (Option.isNone(handler)) return yield* fail(\"handler_unavailable\");\n        const auth = yield* resolveAuth(\n          found.provider.identifier,\n          request.channelId,\n          definition,\n          request.connectionId,\n          command.kind,\n          request.context,\n        );\n        // Keep correlation facts independent of any mutation by provider code.\n        const operationKey = command.operationKey;\n        const kind = command.kind;\n        const deliveryKey = command.kind === \"deliver\" ? command.deliveryKey : undefined;\n        const assetKey = command.kind === \"read_asset\" ? command.asset.assetKey : undefined;\n        const adapterContext = {\n          definitionSettings,\n          deploymentSettings,\n          ...(auth === undefined ? {} : { auth }),\n        };\n        if (\n          !Predicate.isFunction(handler.value.runtime.execute) ||\n          !Predicate.isFunction(handler.value.runtime.verify) ||\n          !Predicate.isFunction(handler.value.runtime.checkAccess)\n        ) {\n          return yield* fail(\"handler_unavailable\");\n        }\n        if (command.kind === \"receive\") {\n          yield* decodeData(\n            AgentChannel.Verification,\n            yield* invokeHandler(\n              handler.value,\n              Effect.suspend(() => handler.value.runtime.verify(command.request, adapterContext)),\n            ),\n            \"invalid_result\",\n          );\n        }\n        if (command.kind === \"read_asset\") {\n          if (!definition.features.assets) return yield* fail(\"unsupported_feature\");\n          const decision = yield* decodeData(\n            AgentChannel.AccessOutcome,\n            yield* invokeHandler(\n              handler.value,\n              Effect.suspend(() =>\n                handler.value.runtime.checkAccess(command.identity, adapterContext),\n              ),\n            ),\n            \"invalid_result\",\n          );\n          if (decision.decision !== \"allow\") {\n            return yield* new AgentChannel.ChannelError({\n              code: \"provider_failure\",\n              providerCode: \"unauthorized\",\n            });\n          }\n        }\n        const output = yield* invokeHandler(\n          handler.value,\n          Effect.suspend(() => handler.value.runtime.execute(command, adapterContext)),\n        );\n        const result: AgentChannel.Result | AgentChannel.ResultV2 = yield* decodeData(\n          schemas.typeResult,\n          output,\n          \"invalid_result\",\n          kind === \"read_asset\",\n        );\n        if (\n          result.kind !== kind ||\n          result.operationKey !== operationKey ||\n          (result.kind === \"deliver\" && result.deliveryKey !== deliveryKey) ||\n          (result.kind === \"read_asset\" && result.assetKey !== assetKey)\n        ) {\n          return yield* fail(\"invalid_result\");\n        }\n        yield* checkExtensions(definition, result.extensions, \"invalid_result\");\n        if (\n          result.kind === \"deliver\" &&\n          result.status === \"pending\" &&\n          !definition.features.deliveryState\n        ) {\n          return yield* fail(\"invalid_result\");\n        }\n        const allowedEvents: AgentChannel.EventV2[] = [];\n        const deniedEventKeys: string[] = [];\n        if (result.kind === \"receive\") {\n          if (result.deniedEventKeys !== undefined) return yield* fail(\"invalid_result\");\n          if (\n            result.activationProof === \"verified\" &&\n            (result.response === undefined || result.events.length !== 0)\n          ) {\n            return yield* fail(\"invalid_result\");\n          }\n          const eventKeys = new Set<string>();\n          for (const event of result.events) {\n            if (eventKeys.has(event.eventKey)) return yield* fail(\"invalid_result\");\n            eventKeys.add(event.eventKey);\n            if (\n              event.kind === \"message\" &&\n              !checkMessage(definition.features, event.conversation, event.content)\n            ) {\n              return yield* fail(\"invalid_result\");\n            }\n            if (\n              (event.kind === \"echo\" || event.kind === \"stop\") &&\n              !checkMessage(definition.features, event.conversation, { text: \"\" })\n            ) {\n              return yield* fail(\"invalid_result\");\n            }\n            if (event.kind === \"delivery_update\" && !definition.features.deliveryState) {\n              return yield* fail(\"invalid_result\");\n            }\n            yield* checkExtensions(definition, event.extensions, \"invalid_result\");\n            let denied = false;\n            if (event.kind === \"message\" || event.kind === \"echo\" || event.kind === \"stop\") {\n              const identity = yield* decodeData(\n                AgentChannel.VerifiedIdentity,\n                { conversation: event.conversation, senderKey: event.senderKey },\n                \"invalid_result\",\n              );\n              const decision = yield* decodeData(\n                AgentChannel.AccessOutcome,\n                yield* invokeHandler(\n                  handler.value,\n                  Effect.suspend(() => handler.value.runtime.checkAccess(identity, adapterContext)),\n                ),\n                \"invalid_result\",\n              );\n              denied = decision.decision === \"deny\";\n            }\n            if (denied) {\n              deniedEventKeys.push(event.eventKey);\n              continue;\n            }\n            allowedEvents.push(event);\n          }\n        }\n        // Store the encoded state so subsequent pinned commands can decode it exactly once.\n        const encoded = yield* safe(\n          Schema.encodeUnknownEffect(schemas.result)(\n            result.kind === \"receive\"\n              ? {\n                  ...result,\n                  events: allowedEvents,\n                  ...(deniedEventKeys.length === 0 ? {} : { deniedEventKeys }),\n                }\n              : result,\n            strict,\n          ),\n          \"invalid_result\",\n        );\n        return yield* decodeData(\n          AgentChannel.CheckedResult,\n          encoded,\n          \"invalid_result\",\n          kind === \"read_asset\",\n        );\n      });\n      // SAFETY: Requirements above account for each schema, auth method and Channel handler. The\n      // dynamic lookup erases their union; the captured application context discharges it here.\n      const run = <A>(\n        effect: Effect.Effect<A, AgentChannel.ChannelError, unknown>,\n      ): Effect.Effect<A, AgentChannel.ChannelError> =>\n        // @effect-diagnostics-next-line unsafeEffectTypeAssertion:off -- Channel handlers are checked and their captured context satisfies the declared Requirements (SAFETY above).\n        effect.pipe(Effect.provideContext(context)) as Effect.Effect<A, AgentChannel.ChannelError>;\n      const decodeSettings = (field: \"definitionSettings\" | \"deploymentSettings\") =>\n        Effect.fn(\"AgentChannelRuntime.decodeSettings\")(function* (input: unknown) {\n          const request = yield* decode(\n            Schema.Struct({ ...Pin.fields, value: Schema.Json }),\n            input,\n            \"invalid_input\",\n          );\n          const definition = yield* get({ channelId: request.channelId });\n          const schema = definition[field];\n          const value = yield* decodeData(schema, request.value, \"invalid_input\");\n          return yield* json(\n            yield* safe(Schema.encodeUnknownEffect(schema)(value, strict), \"invalid_input\"),\n            \"invalid_input\",\n          );\n        });\n      return Service.of({\n        checkAccess: input => run(checkAccess(input)),\n        decodeDefinitionSettings: input => run(decodeSettings(\"definitionSettings\")(input)),\n        decodeDeploymentSettings: input => run(decodeSettings(\"deploymentSettings\")(input)),\n        execute: input => run(execute(input)),\n        get: input => run(get(input)),\n      });\n    }),\n  );\n\nexport * as AgentChannelRuntime from \"./AgentChannelRuntime.ts\";\n"],"mappings":"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"}