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

package/dist/ConnectionResolver.d.ts

@@ -0,0 +1,219 @@
+import "./ConnectionResolver.js";
+import { Context, Effect, Schema } from "effect";
+declare namespace ConnectionResolver_d_exports {
+  export { ConnectionError, ConnectionIdNotAllowedError, ConnectionReauthorizationRequiredError, ConnectionRequiredError, ConnectionResolutionActor, ConnectionResolutionContext, ConnectionResolutionSource, ConnectionResolutionTarget, ConnectionResolutionTenant, ConnectionResolver_d_exports as ConnectionResolver, ConnectionResolverInstance, ConnectionResolverStoreError, ConnectionSelectionRequiredError, ConnectionTargetKind, InvalidConnectionIdError, InvalidResolvedConnectionError, ResolveConnectionError, ResolveConnectionRequest, ResolvedConnectionMaterial, Service };
+}
+/**
+ * Connection-aware runtime targets supported by the SDK.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export type ConnectionTargetKind = "action" | "trigger" | "ai_model" | "agent-channel";
+/**
+ * Tenant boundary for connection resolution and audit.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface ConnectionResolutionTenant {
+  readonly organizationId: string;
+  readonly teamId: string;
+}
+/**
+ * Product actor on whose behalf a connection is being selected.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export type ConnectionResolutionActor = {
+  readonly kind: "user";
+  readonly userId: string;
+} | {
+  readonly kind: "system";
+  readonly reason?: string | undefined;
+};
+/**
+ * Product source that caused the invocation.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface ConnectionResolutionSource {
+  readonly kind: string;
+  readonly subjectId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Host-owned context used to select, authorize, and audit a connection.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface ConnectionResolutionContext {
+  readonly tenant?: ConnectionResolutionTenant;
+  readonly actor?: ConnectionResolutionActor;
+  readonly source?: ConnectionResolutionSource;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Request sent to the host connection resolver during action or trigger execution.
+ *
+ * @since 0.0.0
+ * @category models
+ */
+export interface ConnectionResolutionTarget {
+  readonly providerId: string;
+  readonly targetKind: ConnectionTargetKind;
+  readonly targetId: string;
+  readonly phase?: string;
+}
+export interface ResolveConnectionRequest {
+  readonly target: ConnectionResolutionTarget;
+  readonly connectionId?: string;
+  readonly context?: ConnectionResolutionContext;
+}
+export interface ResolvedConnectionMaterial {
+  readonly encoding?: "json";
+  readonly providerId: string;
+  readonly connectionId: string;
+  readonly methodId: string;
+  readonly material: unknown;
+  readonly setup: unknown;
+}
+declare const ConnectionIdNotAllowedError_base: Schema.Class<ConnectionIdNotAllowedError, Schema.TaggedStruct<"ConnectionIdNotAllowedError", {
+  readonly connectionId: Schema.String;
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a runtime target does not accept a connection but a connectionId was still provided.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class ConnectionIdNotAllowedError extends ConnectionIdNotAllowedError_base {}
+declare const ConnectionRequiredError_base: Schema.Class<ConnectionRequiredError, Schema.TaggedStruct<"ConnectionRequiredError", {
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when execution requires a connection and no compatible binding is available.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class ConnectionRequiredError extends ConnectionRequiredError_base {}
+declare const ConnectionSelectionRequiredError_base: Schema.Class<ConnectionSelectionRequiredError, Schema.TaggedStruct<"ConnectionSelectionRequiredError", {
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when several compatible connection bindings exist and the caller must choose one.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class ConnectionSelectionRequiredError extends ConnectionSelectionRequiredError_base {}
+declare const InvalidConnectionIdError_base: Schema.Class<InvalidConnectionIdError, Schema.TaggedStruct<"InvalidConnectionIdError", {
+  readonly connectionId: Schema.String;
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when the requested connectionId does not resolve to a compatible binding.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class InvalidConnectionIdError extends InvalidConnectionIdError_base {}
+declare const InvalidResolvedConnectionError_base: Schema.Class<InvalidResolvedConnectionError, Schema.TaggedStruct<"InvalidResolvedConnectionError", {
+  readonly description: Schema.String;
+  readonly methodId: Schema.String;
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when the resolved connection value does not satisfy the selected auth method schema.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class InvalidResolvedConnectionError extends InvalidResolvedConnectionError_base {}
+declare const ConnectionReauthorizationRequiredError_base: Schema.Class<ConnectionReauthorizationRequiredError, Schema.TaggedStruct<"ConnectionReauthorizationRequiredError", {
+  readonly connectionId: Schema.String;
+  readonly message: Schema.String;
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when the provider refuses the connection's stored grant, so the user must sign in again.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class ConnectionReauthorizationRequiredError extends ConnectionReauthorizationRequiredError_base {}
+declare const ConnectionResolverStoreError_base: Schema.Class<ConnectionResolverStoreError, Schema.TaggedStruct<"ConnectionResolverStoreError", {
+  readonly cause: Schema.Defect;
+  readonly operation: Schema.String;
+  readonly phase: Schema.optional<Schema.String>;
+  readonly providerId: Schema.String;
+  readonly targetId: Schema.String;
+  readonly targetKind: Schema.Literals<readonly ["action", "trigger", "ai_model", "agent-channel"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when the host credential store cannot be read during connection resolution.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class ConnectionResolverStoreError extends ConnectionResolverStoreError_base {}
+/**
+ * Structured connection failures surfaced by SDK runtime boundaries.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export type ConnectionError = ConnectionIdNotAllowedError | ConnectionRequiredError | ConnectionSelectionRequiredError | InvalidConnectionIdError | InvalidResolvedConnectionError | ConnectionReauthorizationRequiredError | ConnectionResolverStoreError;
+/**
+ * Errors the host resolver itself is expected to surface.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export type ResolveConnectionError = ConnectionRequiredError | ConnectionSelectionRequiredError | InvalidConnectionIdError | InvalidResolvedConnectionError | ConnectionReauthorizationRequiredError | ConnectionResolverStoreError;
+/**
+ * Host-provided service used by SDK runtimes to select one concrete connection binding.
+ *
+ * The SDK narrows and validates this untyped host binding against the target's allowed methods
+ * before exposing it to handlers.
+ *
+ * @since 0.0.0
+ * @category services
+ */
+export interface ConnectionResolverInstance {
+  readonly resolve: (input: ResolveConnectionRequest) => Effect.Effect<ResolvedConnectionMaterial, ResolveConnectionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@dual-os/sdk/ConnectionResolver", ConnectionResolverInstance>;
+/**
+ * Host-provided connection resolver service.
+ *
+ * @since 0.0.0
+ * @category services
+ */
+export declare class Service extends Service_base {}
+//#endregion
+export { ConnectionResolver_d_exports as ConnectionResolver, ConnectionResolver_d_exports };
+//# sourceMappingURL=ConnectionResolver.d.ts.map

package/dist/ConnectionResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionResolver.d.ts","names":[],"sources":["../src/ConnectionResolver.ts"],"mappings":";;;;;;;;;;;YAcY;;;;;;;iBAQK;WACN;WACA;;;;;;;;YASC;WACG;WAAuB;;WACvB;WAAyB;;;;;;;;iBAQvB;WACN;WACA;WACA,WAAW,SAAS;;;;;;;;iBASd;WACN,SAAS;WACT,QAAQ;WACR,SAAS;WACT,WAAW,SAAS;;;;;;;;iBASd;WACN;WACA,YAAY;WACZ;WACA;;iBAGM;WACN,QAAQ;WACR;WACA,UAAU;;iBAGJ;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;;;qBASE,oCAAoC;;;;;;;;;;;;;qBAiBpC,gCAAgC;;;;;;;;;;;;;qBAgBhC,yCAAyC;;;;;;;;;;;;;;qBAgBzC,iCAAiC;;;;;;;;;;;;;;;qBAiBjC,uCAAuC;;;;;;;;;;;;;;;qBAkBvC,+CAA+C;;;;;;;;;;;;;;;qBAkB/C,qCAAqC;;;;;;;YAkBtC,kBACR,8BACA,0BACA,mCACA,2BACA,iCACA,yCACA;;;;;;;YAQQ,yBACR,0BACA,mCACA,2BACA,iCACA,yCACA;;;;;;;;;;iBAWa;WACN,UACP,OAAO,6BACJ,OAAO,OAAO,4BAA4B;;;;;;;;;qBASpC,gBAAgB"}

package/dist/ConnectionResolver.js

@@ -0,0 +1,153 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import "./ConnectionResolver.js";
+import { Context, Schema } from "effect";
+//#region src/ConnectionResolver.ts
+var ConnectionResolver_exports = /* @__PURE__ */ __exportAll({
+	ConnectionIdNotAllowedError: () => ConnectionIdNotAllowedError,
+	ConnectionReauthorizationRequiredError: () => ConnectionReauthorizationRequiredError,
+	ConnectionRequiredError: () => ConnectionRequiredError,
+	ConnectionResolver: () => ConnectionResolver_exports,
+	ConnectionResolverStoreError: () => ConnectionResolverStoreError,
+	ConnectionSelectionRequiredError: () => ConnectionSelectionRequiredError,
+	InvalidConnectionIdError: () => InvalidConnectionIdError,
+	InvalidResolvedConnectionError: () => InvalidResolvedConnectionError,
+	Service: () => Service
+});
+/**
+* Raised when a runtime target does not accept a connection but a connectionId was still provided.
+*
+* @since 0.0.0
+* @category errors
+*/
+var ConnectionIdNotAllowedError = class extends Schema.TaggedError()("ConnectionIdNotAllowedError", {
+	connectionId: Schema.String,
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when execution requires a connection and no compatible binding is available.
+*
+* @since 0.0.0
+* @category errors
+*/
+var ConnectionRequiredError = class extends Schema.TaggedError()("ConnectionRequiredError", {
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when several compatible connection bindings exist and the caller must choose one.
+*
+* @since 0.0.0
+* @category errors
+*/
+var ConnectionSelectionRequiredError = class extends Schema.TaggedError()("ConnectionSelectionRequiredError", {
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when the requested connectionId does not resolve to a compatible binding.
+*
+* @since 0.0.0
+* @category errors
+*/
+var InvalidConnectionIdError = class extends Schema.TaggedError()("InvalidConnectionIdError", {
+	connectionId: Schema.String,
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when the resolved connection value does not satisfy the selected auth method schema.
+*
+* @since 0.0.0
+* @category errors
+*/
+var InvalidResolvedConnectionError = class extends Schema.TaggedError()("InvalidResolvedConnectionError", {
+	description: Schema.String,
+	methodId: Schema.String,
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when the provider refuses the connection's stored grant, so the user must sign in again.
+*
+* @since 0.0.0
+* @category errors
+*/
+var ConnectionReauthorizationRequiredError = class extends Schema.TaggedError()("ConnectionReauthorizationRequiredError", {
+	connectionId: Schema.String,
+	message: Schema.String,
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Raised when the host credential store cannot be read during connection resolution.
+*
+* @since 0.0.0
+* @category errors
+*/
+var ConnectionResolverStoreError = class extends Schema.TaggedError()("ConnectionResolverStoreError", {
+	cause: Schema.Defect(),
+	operation: Schema.String,
+	phase: Schema.optional(Schema.String),
+	providerId: Schema.String,
+	targetId: Schema.String,
+	targetKind: Schema.Literals([
+		"action",
+		"trigger",
+		"ai_model",
+		"agent-channel"
+	])
+}) {};
+/**
+* Host-provided connection resolver service.
+*
+* @since 0.0.0
+* @category services
+*/
+var Service = class extends Context.Service()("@dual-os/sdk/ConnectionResolver") {};
+//#endregion
+export { ConnectionIdNotAllowedError, ConnectionReauthorizationRequiredError, ConnectionRequiredError, ConnectionResolver_exports as ConnectionResolver, ConnectionResolverStoreError, ConnectionResolver_exports, ConnectionSelectionRequiredError, InvalidConnectionIdError, InvalidResolvedConnectionError, Service };
+
+//# sourceMappingURL=ConnectionResolver.js.map

package/dist/ConnectionResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionResolver.js","names":[],"sources":["../src/ConnectionResolver.ts"],"sourcesContent":["/**\n * Host-provided connection resolution contracts for SDK execution flows.\n *\n * @since 0.0.0\n */\nimport type { Effect } from \"effect\";\nimport { Context, Schema } from \"effect\";\n\n/**\n * Connection-aware runtime targets supported by the SDK.\n *\n * @since 0.0.0\n * @category models\n */\nexport type ConnectionTargetKind = \"action\" | \"trigger\" | \"ai_model\" | \"agent-channel\";\n\n/**\n * Tenant boundary for connection resolution and audit.\n *\n * @since 0.0.0\n * @category models\n */\nexport interface ConnectionResolutionTenant {\n  readonly organizationId: string;\n  readonly teamId: string;\n}\n\n/**\n * Product actor on whose behalf a connection is being selected.\n *\n * @since 0.0.0\n * @category models\n */\nexport type ConnectionResolutionActor =\n  | { readonly kind: \"user\"; readonly userId: string }\n  | { readonly kind: \"system\"; readonly reason?: string | undefined };\n\n/**\n * Product source that caused the invocation.\n *\n * @since 0.0.0\n * @category models\n */\nexport interface ConnectionResolutionSource {\n  readonly kind: string;\n  readonly subjectId?: string;\n  readonly metadata?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * Host-owned context used to select, authorize, and audit a connection.\n *\n * @since 0.0.0\n * @category models\n */\nexport interface ConnectionResolutionContext {\n  readonly tenant?: ConnectionResolutionTenant;\n  readonly actor?: ConnectionResolutionActor;\n  readonly source?: ConnectionResolutionSource;\n  readonly metadata?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * Request sent to the host connection resolver during action or trigger execution.\n *\n * @since 0.0.0\n * @category models\n */\nexport interface ConnectionResolutionTarget {\n  readonly providerId: string;\n  readonly targetKind: ConnectionTargetKind;\n  readonly targetId: string;\n  readonly phase?: string;\n}\n\nexport interface ResolveConnectionRequest {\n  readonly target: ConnectionResolutionTarget;\n  readonly connectionId?: string;\n  readonly context?: ConnectionResolutionContext;\n}\n\nexport interface ResolvedConnectionMaterial {\n  readonly encoding?: \"json\";\n  readonly providerId: string;\n  readonly connectionId: string;\n  readonly methodId: string;\n  readonly material: unknown;\n  readonly setup: unknown;\n}\n\n/**\n * Raised when a runtime target does not accept a connection but a connectionId was still provided.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class ConnectionIdNotAllowedError extends Schema.TaggedError<ConnectionIdNotAllowedError>()(\n  \"ConnectionIdNotAllowedError\",\n  {\n    connectionId: Schema.String,\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when execution requires a connection and no compatible binding is available.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class ConnectionRequiredError extends Schema.TaggedError<ConnectionRequiredError>()(\n  \"ConnectionRequiredError\",\n  {\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when several compatible connection bindings exist and the caller must choose one.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class ConnectionSelectionRequiredError extends Schema.TaggedError<ConnectionSelectionRequiredError>()(\n  \"ConnectionSelectionRequiredError\",\n  {\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when the requested connectionId does not resolve to a compatible binding.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class InvalidConnectionIdError extends Schema.TaggedError<InvalidConnectionIdError>()(\n  \"InvalidConnectionIdError\",\n  {\n    connectionId: Schema.String,\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when the resolved connection value does not satisfy the selected auth method schema.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class InvalidResolvedConnectionError extends Schema.TaggedError<InvalidResolvedConnectionError>()(\n  \"InvalidResolvedConnectionError\",\n  {\n    description: Schema.String,\n    methodId: Schema.String,\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when the provider refuses the connection's stored grant, so the user must sign in again.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class ConnectionReauthorizationRequiredError extends Schema.TaggedError<ConnectionReauthorizationRequiredError>()(\n  \"ConnectionReauthorizationRequiredError\",\n  {\n    connectionId: Schema.String,\n    message: Schema.String,\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Raised when the host credential store cannot be read during connection resolution.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class ConnectionResolverStoreError extends Schema.TaggedError<ConnectionResolverStoreError>()(\n  \"ConnectionResolverStoreError\",\n  {\n    cause: Schema.Defect(),\n    operation: Schema.String,\n    phase: Schema.optional(Schema.String),\n    providerId: Schema.String,\n    targetId: Schema.String,\n    targetKind: Schema.Literals([\"action\", \"trigger\", \"ai_model\", \"agent-channel\"]),\n  },\n) {}\n\n/**\n * Structured connection failures surfaced by SDK runtime boundaries.\n *\n * @since 0.0.0\n * @category errors\n */\nexport type ConnectionError =\n  | ConnectionIdNotAllowedError\n  | ConnectionRequiredError\n  | ConnectionSelectionRequiredError\n  | InvalidConnectionIdError\n  | InvalidResolvedConnectionError\n  | ConnectionReauthorizationRequiredError\n  | ConnectionResolverStoreError;\n\n/**\n * Errors the host resolver itself is expected to surface.\n *\n * @since 0.0.0\n * @category errors\n */\nexport type ResolveConnectionError =\n  | ConnectionRequiredError\n  | ConnectionSelectionRequiredError\n  | InvalidConnectionIdError\n  | InvalidResolvedConnectionError\n  | ConnectionReauthorizationRequiredError\n  | ConnectionResolverStoreError;\n\n/**\n * Host-provided service used by SDK runtimes to select one concrete connection binding.\n *\n * The SDK narrows and validates this untyped host binding against the target's allowed methods\n * before exposing it to handlers.\n *\n * @since 0.0.0\n * @category services\n */\nexport interface ConnectionResolverInstance {\n  readonly resolve: (\n    input: ResolveConnectionRequest,\n  ) => Effect.Effect<ResolvedConnectionMaterial, ResolveConnectionError>;\n}\n\n/**\n * Host-provided connection resolver service.\n *\n * @since 0.0.0\n * @category services\n */\nexport class Service extends Context.Service<Service, ConnectionResolverInstance>()(\n  \"@dual-os/sdk/ConnectionResolver\",\n) {}\n\nexport * as ConnectionResolver from \"./ConnectionResolver.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAgGA,IAAa,8BAAb,cAAiD,OAAO,YAAyC,CAAC,CAChG,+BACA;CACE,cAAc,OAAO;CACrB,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,0BAAb,cAA6C,OAAO,YAAqC,CAAC,CACxF,2BACA;CACE,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,mCAAb,cAAsD,OAAO,YAA8C,CAAC,CAC1G,oCACA;CACE,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,2BAAb,cAA8C,OAAO,YAAsC,CAAC,CAC1F,4BACA;CACE,cAAc,OAAO;CACrB,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,iCAAb,cAAoD,OAAO,YAA4C,CAAC,CACtG,kCACA;CACE,aAAa,OAAO;CACpB,UAAU,OAAO;CACjB,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,yCAAb,cAA4D,OAAO,YAAoD,CAAC,CACtH,0CACA;CACE,cAAc,OAAO;CACrB,SAAS,OAAO;CAChB,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,+BAAb,cAAkD,OAAO,YAA0C,CAAC,CAClG,gCACA;CACE,OAAO,OAAO,OAAO;CACrB,WAAW,OAAO;CAClB,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,YAAY,OAAO;CACnB,UAAU,OAAO;CACjB,YAAY,OAAO,SAAS;EAAC;EAAU;EAAW;EAAY;CAAe,CAAC;AAChF,CACF,CAAC,CAAC,CAAC;;;;;;;AAoDH,IAAa,UAAb,cAA6B,QAAQ,QAA6C,CAAC,CACjF,iCACF,CAAC,CAAC,CAAC"}

package/dist/DefinitionError.d.ts

@@ -0,0 +1,67 @@
+import { Schema } from "effect";
+declare namespace DefinitionError_d_exports {
+  export { BuilderCollisionError, DefinitionChildKind, DefinitionIdentifierKind, DefinitionOwnerKind, DuplicateAuthMethodIdentifierError, InvalidIdentifierError, InvalidIdentifierReason };
+}
+/**
+ * @since 0.0.0
+ * @category models
+ */
+export type DefinitionIdentifierKind = "dual" | "plugin" | "provider" | "group" | "action" | "trigger" | "auth-method" | "agent-channel";
+/**
+ * @since 0.0.0
+ * @category models
+ */
+export type DefinitionOwnerKind = "dual" | "plugin" | "group";
+/**
+ * @since 0.0.0
+ * @category models
+ */
+export type DefinitionChildKind = "plugin" | "provider" | "group" | "action" | "trigger" | "agent-channel";
+/**
+ * @since 0.0.0
+ * @category models
+ */
+export type InvalidIdentifierReason = "empty" | "contains-reserved-separator" | "invalid-format";
+declare const InvalidIdentifierError_base: Schema.Class<InvalidIdentifierError, Schema.TaggedStruct<"InvalidIdentifierError", {
+  readonly identifier: Schema.String;
+  readonly kind: Schema.Literals<readonly ["dual", "plugin", "provider", "group", "action", "trigger", "auth-method", "agent-channel"]>;
+  readonly reason: Schema.Literals<readonly ["empty", "contains-reserved-separator", "invalid-format"]>;
+  readonly reservedCharacter: Schema.optional<Schema.Literals<readonly ["/"]>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a definition identifier does not satisfy SDK constraints.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class InvalidIdentifierError extends InvalidIdentifierError_base {}
+declare const BuilderCollisionError_base: Schema.Class<BuilderCollisionError, Schema.TaggedStruct<"BuilderCollisionError", {
+  readonly childKind: Schema.Literals<readonly ["agent-channel", "plugin", "provider", "group", "action", "trigger"]>;
+  readonly childPluginIdentifier: Schema.optional<Schema.String>;
+  readonly existingChildKind: Schema.Literals<readonly ["agent-channel", "plugin", "provider", "group", "action", "trigger"]>;
+  readonly existingPluginIdentifier: Schema.optional<Schema.String>;
+  readonly identifier: Schema.String;
+  readonly ownerIdentifier: Schema.String;
+  readonly ownerKind: Schema.Literals<readonly ["dual", "plugin", "group"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when two sibling definitions reuse the same identifier.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class BuilderCollisionError extends BuilderCollisionError_base {}
+declare const DuplicateAuthMethodIdentifierError_base: Schema.Class<DuplicateAuthMethodIdentifierError, Schema.TaggedStruct<"DuplicateAuthMethodIdentifierError", {
+  readonly identifier: Schema.String;
+  readonly providerIdentifier: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a provider reuses an auth method identifier.
+ *
+ * @since 0.0.0
+ * @category errors
+ */
+export declare class DuplicateAuthMethodIdentifierError extends DuplicateAuthMethodIdentifierError_base {}
+//#endregion
+export { DefinitionError_d_exports };
+//# sourceMappingURL=DefinitionError.d.ts.map

package/dist/DefinitionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefinitionError.d.ts","names":[],"sources":["../src/DefinitionError.ts"],"mappings":";;;;;;;;YAWY;;;;;YAcA;;;;;YAMA;;;;;YAYA;;;;;;;;;;;;;qBAiCC,+BAA+B;;;;;;;;;;;;;;;;qBAgB/B,8BAA8B;;;;;;;;;;;qBAmB9B,2CAA2C"}

package/dist/DefinitionError.js

@@ -0,0 +1,82 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Schema } from "effect";
+//#region src/DefinitionError.ts
+/**
+* Public SDK definition errors.
+*
+* @since 0.0.0
+*/
+var DefinitionError_exports = /* @__PURE__ */ __exportAll({
+	BuilderCollisionError: () => BuilderCollisionError,
+	DuplicateAuthMethodIdentifierError: () => DuplicateAuthMethodIdentifierError,
+	InvalidIdentifierError: () => InvalidIdentifierError
+});
+const DefinitionIdentifierKindSchema = Schema.Literals([
+	"dual",
+	"plugin",
+	"provider",
+	"group",
+	"action",
+	"trigger",
+	"auth-method",
+	"agent-channel"
+]);
+const DefinitionOwnerKindSchema = Schema.Literals([
+	"dual",
+	"plugin",
+	"group"
+]);
+const DefinitionChildKindSchema = Schema.Literals([
+	"agent-channel",
+	"plugin",
+	"provider",
+	"group",
+	"action",
+	"trigger"
+]);
+const InvalidIdentifierReasonSchema = Schema.Literals([
+	"empty",
+	"contains-reserved-separator",
+	"invalid-format"
+]);
+/**
+* Raised when a definition identifier does not satisfy SDK constraints.
+*
+* @since 0.0.0
+* @category errors
+*/
+var InvalidIdentifierError = class extends Schema.TaggedError()("InvalidIdentifierError", {
+	identifier: Schema.String,
+	kind: DefinitionIdentifierKindSchema,
+	reason: InvalidIdentifierReasonSchema,
+	reservedCharacter: Schema.optional(Schema.Literals(["/"]))
+}) {};
+/**
+* Raised when two sibling definitions reuse the same identifier.
+*
+* @since 0.0.0
+* @category errors
+*/
+var BuilderCollisionError = class extends Schema.TaggedError()("BuilderCollisionError", {
+	childKind: DefinitionChildKindSchema,
+	childPluginIdentifier: Schema.optional(Schema.String),
+	existingChildKind: DefinitionChildKindSchema,
+	existingPluginIdentifier: Schema.optional(Schema.String),
+	identifier: Schema.String,
+	ownerIdentifier: Schema.String,
+	ownerKind: DefinitionOwnerKindSchema
+}) {};
+/**
+* Raised when a provider reuses an auth method identifier.
+*
+* @since 0.0.0
+* @category errors
+*/
+var DuplicateAuthMethodIdentifierError = class extends Schema.TaggedError()("DuplicateAuthMethodIdentifierError", {
+	identifier: Schema.String,
+	providerIdentifier: Schema.String
+}) {};
+//#endregion
+export { BuilderCollisionError, DefinitionError_exports, DuplicateAuthMethodIdentifierError, InvalidIdentifierError };
+
+//# sourceMappingURL=DefinitionError.js.map

package/dist/DefinitionError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefinitionError.js","names":[],"sources":["../src/DefinitionError.ts"],"sourcesContent":["/**\n * Public SDK definition errors.\n *\n * @since 0.0.0\n */\nimport { Schema } from \"effect\";\n\n/**\n * @since 0.0.0\n * @category models\n */\nexport type DefinitionIdentifierKind =\n  | \"dual\"\n  | \"plugin\"\n  | \"provider\"\n  | \"group\"\n  | \"action\"\n  | \"trigger\"\n  | \"auth-method\"\n  | \"agent-channel\";\n\n/**\n * @since 0.0.0\n * @category models\n */\nexport type DefinitionOwnerKind = \"dual\" | \"plugin\" | \"group\";\n\n/**\n * @since 0.0.0\n * @category models\n */\nexport type DefinitionChildKind =\n  | \"plugin\"\n  | \"provider\"\n  | \"group\"\n  | \"action\"\n  | \"trigger\"\n  | \"agent-channel\";\n\n/**\n * @since 0.0.0\n * @category models\n */\nexport type InvalidIdentifierReason = \"empty\" | \"contains-reserved-separator\" | \"invalid-format\";\n\nconst DefinitionIdentifierKindSchema = Schema.Literals([\n  \"dual\",\n  \"plugin\",\n  \"provider\",\n  \"group\",\n  \"action\",\n  \"trigger\",\n  \"auth-method\",\n  \"agent-channel\",\n]);\nconst DefinitionOwnerKindSchema = Schema.Literals([\"dual\", \"plugin\", \"group\"]);\nconst DefinitionChildKindSchema = Schema.Literals([\n  \"agent-channel\",\n  \"plugin\",\n  \"provider\",\n  \"group\",\n  \"action\",\n  \"trigger\",\n]);\nconst InvalidIdentifierReasonSchema = Schema.Literals([\n  \"empty\",\n  \"contains-reserved-separator\",\n  \"invalid-format\",\n]);\n\n/**\n * Raised when a definition identifier does not satisfy SDK constraints.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class InvalidIdentifierError extends Schema.TaggedError<InvalidIdentifierError>()(\n  \"InvalidIdentifierError\",\n  {\n    identifier: Schema.String,\n    kind: DefinitionIdentifierKindSchema,\n    reason: InvalidIdentifierReasonSchema,\n    reservedCharacter: Schema.optional(Schema.Literals([\"/\"])),\n  },\n) {}\n\n/**\n * Raised when two sibling definitions reuse the same identifier.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class BuilderCollisionError extends Schema.TaggedError<BuilderCollisionError>()(\n  \"BuilderCollisionError\",\n  {\n    childKind: DefinitionChildKindSchema,\n    childPluginIdentifier: Schema.optional(Schema.String),\n    existingChildKind: DefinitionChildKindSchema,\n    existingPluginIdentifier: Schema.optional(Schema.String),\n    identifier: Schema.String,\n    ownerIdentifier: Schema.String,\n    ownerKind: DefinitionOwnerKindSchema,\n  },\n) {}\n\n/**\n * Raised when a provider reuses an auth method identifier.\n *\n * @since 0.0.0\n * @category errors\n */\nexport class DuplicateAuthMethodIdentifierError extends Schema.TaggedError<DuplicateAuthMethodIdentifierError>()(\n  \"DuplicateAuthMethodIdentifierError\",\n  { identifier: Schema.String, providerIdentifier: Schema.String },\n) {}\n"],"mappings":";;;;;;;;;;;;;AA6CA,MAAM,iCAAiC,OAAO,SAAS;CACrD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AACD,MAAM,4BAA4B,OAAO,SAAS;CAAC;CAAQ;CAAU;AAAO,CAAC;AAC7E,MAAM,4BAA4B,OAAO,SAAS;CAChD;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AACD,MAAM,gCAAgC,OAAO,SAAS;CACpD;CACA;CACA;AACF,CAAC;;;;;;;AAQD,IAAa,yBAAb,cAA4C,OAAO,YAAoC,CAAC,CACtF,0BACA;CACE,YAAY,OAAO;CACnB,MAAM;CACN,QAAQ;CACR,mBAAmB,OAAO,SAAS,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC;AAC3D,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,wBAAb,cAA2C,OAAO,YAAmC,CAAC,CACpF,yBACA;CACE,WAAW;CACX,uBAAuB,OAAO,SAAS,OAAO,MAAM;CACpD,mBAAmB;CACnB,0BAA0B,OAAO,SAAS,OAAO,MAAM;CACvD,YAAY,OAAO;CACnB,iBAAiB,OAAO;CACxB,WAAW;AACb,CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,qCAAb,cAAwD,OAAO,YAAgD,CAAC,CAC9G,sCACA;CAAE,YAAY,OAAO;CAAQ,oBAAoB,OAAO;AAAO,CACjE,CAAC,CAAC,CAAC"}

package/dist/DualRegistry.d.ts

@@ -0,0 +1,71 @@
+import { Any } from "./Plugin.js";
+import { Any as Any$1 } from "./AiProvider.js";
+import { AllActionEntries } from "./internal/dual/actions.js";
+import { AnyApp, App } from "./DualRuntime.js";
+import { MaterializedActionCapabilityVersion, MaterializedAuthMethod, MaterializedCapabilityVersion, MaterializedChannelCapabilityVersion, MaterializedProvider, MaterializedRegistry, MaterializedRegistryOptions, MaterializedTriggerCapabilityVersion } from "./internal/dual/registry.js";
+import { AllTriggerEntries, RuntimeTriggerEntry } from "./internal/dual/triggers.js";
+import "./DualRegistry.js";
+import { Schema } from "effect";
+declare namespace DualRegistry_d_exports {
+  export { DualRegistry_d_exports as DualRegistry, MaterializedActionCapabilityVersion, MaterializedAuthMethod, MaterializedCapabilityVersion, MaterializedChannelCapabilityVersion, MaterializedPlugin, MaterializedProvider, MaterializedRegistry, MaterializedRegistryOptions, MaterializedTriggerCapabilityVersion, TriggerNotFoundError, actionIds, materializePlugin, materializePlugins, materializeRegistry, resolveTrigger, triggerIds };
+}
+declare const TriggerNotFoundError_base: Schema.Class<TriggerNotFoundError, Schema.TaggedStruct<"TriggerNotFoundError", {
+  readonly triggerId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a trigger lifecycle request references an unknown trigger id. */
+export declare class TriggerNotFoundError extends TriggerNotFoundError_base {}
+/**
+ * Enumerate the canonical machine ids for every action in the app.
+ *
+ * @since 0.0.0
+ * @category getters
+ */
+export declare const actionIds: <const P extends Any, LayerOutput, LayerError, LayerRequirements, const AiProviders extends readonly Any$1[]>(app: App<P, LayerOutput, LayerError, LayerRequirements, AiProviders>) => readonly AllActionEntries<readonly [P]>["actionId"][];
+/**
+ * Enumerate the canonical machine ids for every trigger in the app.
+ *
+ * @since 0.0.0
+ * @category getters
+ */
+export declare const triggerIds: <const P extends Any, LayerOutput, LayerError, LayerRequirements, const AiProviders extends readonly Any$1[]>(app: App<P, LayerOutput, LayerError, LayerRequirements, AiProviders>) => readonly AllTriggerEntries<readonly [P]>["triggerId"][];
+/**
+ * Resolve one trigger entry from the app, including its auth methods.
+ *
+ * @since 0.0.0
+ * @category getters
+ */
+export declare const resolveTrigger: (app: AnyApp, triggerId: string, options?: {
+  readonly triggerVersion?: string;
+}) => RuntimeTriggerEntry | undefined;
+/**
+ * Materialize the capability catalog of an app's installed releases.
+ *
+ * @since 0.0.0
+ * @category registry
+ */
+export declare const materializeRegistry: (app: AnyApp, options?: MaterializedRegistryOptions) => MaterializedRegistry;
+/** The contracts of one plugin release. @since 0.0.0 @category registry */
+export interface MaterializedPlugin {
+  readonly pluginIdentifier: string;
+  readonly pluginVersion: string;
+  readonly providers: readonly MaterializedRegistry["providers"][number][];
+}
+/**
+ * Extract a release's contracts without building Layers or running handlers.
+ *
+ * @since 0.0.0
+ * @category registry
+ */
+export declare const materializePlugin: (plugin: Any, options: MaterializedRegistryOptions & {
+  readonly version: string;
+}) => MaterializedPlugin;
+/** Every installed plugin release and its contracts. @since 0.0.0 @category registry */
+export declare const materializePlugins: (app: AnyApp, options?: MaterializedRegistryOptions) => {
+  pluginIdentifier: string;
+  pluginVersion: string;
+  providers: readonly MaterializedRegistry["providers"][number][];
+  ordinal: number;
+}[];
+//#endregion
+export { DualRegistry_d_exports as DualRegistry, DualRegistry_d_exports, type MaterializedActionCapabilityVersion, type MaterializedAuthMethod, type MaterializedCapabilityVersion, type MaterializedChannelCapabilityVersion, type MaterializedProvider, type MaterializedRegistry, type MaterializedRegistryOptions, type MaterializedTriggerCapabilityVersion };
+//# sourceMappingURL=DualRegistry.d.ts.map

package/dist/DualRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DualRegistry.d.ts","names":["Plugin.Any","AiProvider.Any"],"sources":["../src/DualRegistry.ts"],"mappings":";;;;;;;;;;;;;;;qBAwBa,6BAA6B;;;;;;;qBAW7B,kBACL,UAAUA,KAChB,aACA,YACA,yBACM,6BAA6BC,SAAgB,KAE9C,IAAI,GAAG,aAAa,YAAY,mBAAmB,0BAC9C,2BAA2B;;;;;;;qBAU1B,mBACL,UAAUD,KAChB,aACA,YACA,yBACM,6BAA6BC,SAAgB,KAE9C,IAAI,GAAG,aAAa,YAAY,mBAAmB,0BAC9C,4BAA4B;;;;;;;qBAU3B,iBAAc,KACpB,QAAM,mBACM;WACG;MACnB;;;;;;;qBAqBU,sBAAmB,KACzB,QAAM,UACF,gCACR;;iBAWc;WACN;WACA;WACA,oBAAoB;;;;;;;;qBASlB,oBAAiB,QACpBD,KAAU,SACT;WAAyC;MACjD;;qBAcU,qBAAkB,KAAS,QAAM,UAAW;EA5B5B;EACH;EACJ,oBAAS"}