@herd-labs/sdk 0.3.1 → 0.4.0

package/dist/src/schemas/wallets.js

@@ -4,11 +4,11 @@ import { Schema } from "effect";
 //#region src/schemas/wallets.ts
 var WalletBalance = class extends Schema.Class("WalletBalance")({
 	address: Schema.String,
-	symbol: Schema.NullOr(Schema.String),
-	amount: Schema.Union(Schema.String, Schema.Number),
+	amount: Schema.Union([Schema.String, Schema.Number]),
 	decimals: Schema.NullOr(Schema.Number),
-	valueUsd: Schema.NullOr(Schema.Number),
-	logoUrl: Schema.NullOr(Schema.String)
+	logoUrl: Schema.NullOr(Schema.String),
+	symbol: Schema.NullOr(Schema.String),
+	valueUsd: Schema.NullOr(Schema.Number)
 }) {};
 var Erc7702Delegation = class extends Schema.Class("Erc7702Delegation")({
 	address: Schema.String,
@@ -20,194 +20,210 @@ var MultisigSigner = class extends Schema.Class("MultisigSigner")({
 	isContract: Schema.Boolean
 }) {};
 var PendingTransaction = class extends Schema.Class("PendingTransaction")({
-	safeTxHash: Schema.String,
-	to: Schema.String,
-	value: Schema.String,
+	confirmationsReceived: Schema.optional(Schema.Number),
+	confirmationsRequired: Schema.optional(Schema.Number),
 	data: Schema.NullOr(Schema.String),
+	method: Schema.optional(Schema.NullOr(Schema.String)),
 	nonce: Schema.Number,
-	submissionDate: Schema.optional(Schema.String),
-	confirmationsRequired: Schema.optional(Schema.Number),
-	confirmationsReceived: Schema.optional(Schema.Number),
 	proposer: Schema.optional(Schema.NullOr(Schema.String)),
-	method: Schema.optional(Schema.NullOr(Schema.String))
+	safeTxHash: Schema.String,
+	submissionDate: Schema.optional(Schema.String),
+	to: Schema.String,
+	value: Schema.String
 }) {};
 var MultisigDetails = class extends Schema.Class("MultisigDetails")({
-	threshold: Schema.Number,
+	pendingTransactions: Schema.Array(PendingTransaction),
 	signers: Schema.Array(MultisigSigner),
-	pendingTransactions: Schema.Array(PendingTransaction)
+	threshold: Schema.Number
 }) {};
 var WalletOverview = class extends Schema.Class("WalletOverview")({
-	walletAddress: Schema.String,
+	balances: Schema.Array(WalletBalance),
 	blockchain: Blockchain,
-	walletType: Schema.Literal("eoa", "erc7702", "erc4337", "multisig", "contract"),
-	implementationAddress: Schema.optional(Schema.String),
+	earliestTx: Schema.NullOr(Schema.Number),
 	erc7702Delegation: Schema.optional(Erc7702Delegation),
+	implementationAddress: Schema.optional(Schema.String),
 	multisigDetails: Schema.optional(MultisigDetails),
-	totalTransactionCount: Schema.Number,
-	earliestTx: Schema.NullOr(Schema.Number),
 	totalDeployedContractsCount: Schema.Number,
-	balances: Schema.Array(WalletBalance)
+	totalTransactionCount: Schema.Number,
+	walletAddress: Schema.String,
+	walletType: Schema.Literals([
+		"eoa",
+		"erc7702",
+		"erc4337",
+		"multisig",
+		"contract"
+	])
 }) {};
 var TokenBalanceInfo = class extends Schema.Class("TokenBalanceInfo")({
-	raw: Schema.String,
+	decimals: Schema.NullOr(Schema.Number),
 	formatted: Schema.String,
-	symbol: Schema.NullOr(Schema.String),
-	decimals: Schema.NullOr(Schema.Number)
+	raw: Schema.String,
+	symbol: Schema.NullOr(Schema.String)
 }) {};
 var TokenTransfer = class extends Schema.Class("TokenTransfer")({
-	txHash: Schema.String,
+	amount: Schema.String,
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	blockTimestampUtc: Schema.String,
-	blockNumber: Schema.Number,
-	logIndex: Schema.Number,
+	direction: Schema.Literals(["in", "out"]),
+	formattedAmount: Schema.String,
 	fromAddress: Schema.String,
+	logIndex: Schema.Number,
 	toAddress: Schema.String,
-	amount: Schema.String,
-	formattedAmount: Schema.String,
-	direction: Schema.Literal("in", "out")
+	txHash: Schema.String
 }) {};
 var TokenActivityPagination = class extends Schema.Class("TokenActivityPagination")({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
+	pageSize: Schema.Number
 }) {};
 var TokenActivity = class extends Schema.Class("TokenActivity")({
+	balance: TokenBalanceInfo,
+	blockchain: Blockchain,
 	holderAddress: Schema.String,
+	pagination: TokenActivityPagination,
 	tokenAddress: Schema.String,
-	blockchain: Blockchain,
-	balance: TokenBalanceInfo,
-	transfers: Schema.Array(TokenTransfer),
-	pagination: TokenActivityPagination
+	transfers: Schema.Array(TokenTransfer)
 }) {};
 var WalletTxCall = class extends Schema.Class("WalletTxCall")({
 	callee: Schema.String,
-	functionSignature: Schema.String,
-	functionName: Schema.String,
 	contractName: Schema.NullOr(Schema.String),
-	entityLabel: Schema.NullOr(Schema.String)
+	entityLabel: Schema.NullOr(Schema.String),
+	functionName: Schema.String,
+	functionSignature: Schema.String
 }) {};
 var WalletTxActionExecution = class extends Schema.Class("WalletTxActionExecution")({
 	actionId: Schema.String,
-	versionId: Schema.String,
 	actionName: Schema.String,
-	executionId: Schema.String
+	executionId: Schema.String,
+	versionId: Schema.String
 }) {};
 var WalletTxTransfer = class extends Schema.Class("WalletTxTransfer")({
-	txHash: Schema.String,
-	blockNumber: Schema.Number,
-	tokenAddress: Schema.String,
-	fromAddress: Schema.String,
-	toAddress: Schema.String,
 	amount: Schema.Number,
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	chainId: Schema.Number,
-	tokenId: Schema.Number,
+	fromAddress: Schema.String,
+	fromAddressIsContract: Schema.Boolean,
+	fromEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
+	toAddress: Schema.String,
+	toAddressIsContract: Schema.Boolean,
+	toEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
+	tokenAddress: Schema.String,
 	tokenDecimals: Schema.Number,
+	tokenId: Schema.Number,
+	tokenLogoUrl: Schema.String,
 	tokenName: Schema.String,
-	tokenSymbol: Schema.String,
 	tokenPriceUsd: Schema.Number,
-	tokenLogoUrl: Schema.String,
-	tokenType: Schema.Literal("NATIVE", "ERC20", "ERC721", "ERC1155"),
-	fromAddressIsContract: Schema.Boolean,
-	toAddressIsContract: Schema.Boolean,
-	fromEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
-	toEntityLabel: Schema.optional(Schema.NullOr(Schema.String))
+	tokenSymbol: Schema.String,
+	tokenType: Schema.Literals([
+		"NATIVE",
+		"ERC20",
+		"ERC721",
+		"ERC1155"
+	]),
+	txHash: Schema.String
 }) {};
 var WalletTxBalanceChange = class extends Schema.Class("WalletTxBalanceChange")({
-	txHash: Schema.optional(Schema.String),
-	blockNumber: Schema.Number,
-	tokenAddress: Schema.String,
-	holderAddress: Schema.String,
-	holderIsContract: Schema.Boolean,
 	balanceChange: Schema.Number,
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	chainId: Schema.Number,
-	tokenType: Schema.Literal("NATIVE", "ERC20", "ERC721", "ERC1155"),
-	tokenId: Schema.Number,
+	holderAddress: Schema.String,
+	holderEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
+	holderIsContract: Schema.Boolean,
+	tokenAddress: Schema.String,
 	tokenDecimals: Schema.Number,
+	tokenEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
+	tokenId: Schema.Number,
+	tokenLogoUrl: Schema.String,
 	tokenName: Schema.String,
-	tokenSymbol: Schema.String,
 	tokenPriceUsd: Schema.Number,
-	tokenLogoUrl: Schema.String,
-	holderEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
-	tokenEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
-	transfers: Schema.Array(WalletTxTransfer)
+	tokenSymbol: Schema.String,
+	tokenType: Schema.Literals([
+		"NATIVE",
+		"ERC20",
+		"ERC721",
+		"ERC1155"
+	]),
+	transfers: Schema.Array(WalletTxTransfer),
+	txHash: Schema.optional(Schema.String)
 }) {};
 var WalletTransaction = class extends Schema.Class("WalletTransaction")({
-	txHash: Schema.String,
+	actionExecution: Schema.optional(WalletTxActionExecution),
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	blockTimestampUtc: Schema.String,
-	blockNumber: Schema.Number,
-	success: Schema.Boolean,
-	errorMessage: Schema.optional(Schema.String),
 	calls: Schema.Array(WalletTxCall),
-	walletBalanceChanges: Schema.Array(WalletTxBalanceChange),
 	createdContracts: Schema.Array(Schema.Struct({
 		address: Schema.String,
 		contractName: Schema.NullOr(Schema.String),
 		entityLabel: Schema.NullOr(Schema.String)
 	})),
-	actionExecution: Schema.optional(WalletTxActionExecution)
+	errorMessage: Schema.optional(Schema.String),
+	success: Schema.Boolean,
+	txHash: Schema.String,
+	walletBalanceChanges: Schema.Array(WalletTxBalanceChange)
 }) {};
 var TransactionActivityPagination = class extends Schema.Class("TransactionActivityPagination")({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
+	pageSize: Schema.Number
 }) {};
 var TransactionActivity = class extends Schema.Class("TransactionActivity")({
-	fromAddress: Schema.String,
 	blockchain: Blockchain,
+	earliestTx: Schema.NullOr(Schema.Number),
+	fromAddress: Schema.String,
+	pagination: TransactionActivityPagination,
 	toAddressesFilter: Schema.optional(Schema.Array(Schema.String)),
 	totalTransactionCount: Schema.Number,
-	earliestTx: Schema.NullOr(Schema.Number),
-	transactions: Schema.Array(WalletTransaction),
-	pagination: TransactionActivityPagination
+	transactions: Schema.Array(WalletTransaction)
 }) {};
 var DeployedContract = class extends Schema.Class("DeployedContract")({
-	contractAddress: Schema.String,
-	contractName: Schema.NullOr(Schema.String),
-	entity: Schema.NullOr(Schema.String),
-	symbol: Schema.NullOr(Schema.String),
 	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	blockTimestampUtc: Schema.String,
+	contractAddress: Schema.String,
+	contractName: Schema.NullOr(Schema.String),
 	deploymentTxnHash: Schema.String,
+	entity: Schema.NullOr(Schema.String),
 	factoryAddress: Schema.NullOr(Schema.String),
-	factoryName: Schema.NullOr(Schema.String)
+	factoryName: Schema.NullOr(Schema.String),
+	symbol: Schema.NullOr(Schema.String)
 }) {};
 var DeployedContractsPagination = class extends Schema.Class("DeployedContractsPagination")({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
+	pageSize: Schema.Number
 }) {};
 var DeployedContracts = class extends Schema.Class("DeployedContracts")({
-	deployerAddress: Schema.String,
 	blockchain: Blockchain,
-	isEOA: Schema.Boolean,
-	totalDeployedContractsCount: Schema.Number,
 	deployedContracts: Schema.Array(DeployedContract),
-	pagination: DeployedContractsPagination
+	deployerAddress: Schema.String,
+	isEOA: Schema.Boolean,
+	pagination: DeployedContractsPagination,
+	totalDeployedContractsCount: Schema.Number
 }) {};
 var TokenActivityParams = class extends Schema.Class("TokenActivityParams")({
-	page: Schema.optional(Schema.Number),
-	beforeTimestamp: Schema.optional(Schema.Number),
+	afterBlocknumber: Schema.optional(Schema.Number),
 	afterTimestamp: Schema.optional(Schema.Number),
 	beforeBlocknumber: Schema.optional(Schema.Number),
-	afterBlocknumber: Schema.optional(Schema.Number),
+	beforeTimestamp: Schema.optional(Schema.Number),
 	fromAddress: Schema.optional(Schema.String),
+	page: Schema.optional(Schema.Number),
 	toAddress: Schema.optional(Schema.String)
 }) {};
 /** Same fields as MCP `getTransactionActivityTool` inputs (camelCase); POST `/v1/wallets/transaction-activity` body uses snake_case. */
 var TransactionActivityQuery = class extends Schema.Class("TransactionActivityQuery")({
+	afterBlocknumber: Schema.optional(Schema.Number),
+	afterTimestamp: Schema.optional(Schema.Number),
+	beforeBlocknumber: Schema.optional(Schema.Number),
+	beforeTimestamp: Schema.optional(Schema.Number),
 	blockchain: Blockchain,
 	fromAddress: Schema.optional(Schema.String),
-	toAddresses: Schema.optional(Schema.Array(Schema.String)),
 	page: Schema.optional(Schema.Number),
-	beforeTimestamp: Schema.optional(Schema.Number),
-	afterTimestamp: Schema.optional(Schema.Number),
-	beforeBlocknumber: Schema.optional(Schema.Number),
-	afterBlocknumber: Schema.optional(Schema.Number),
-	successOnly: Schema.optional(Schema.Boolean)
+	successOnly: Schema.optional(Schema.Boolean),
+	toAddresses: Schema.optional(Schema.Array(Schema.String))
 }) {};
 
 //#endregion

package/dist/src/services/ActionsService.d.ts

@@ -3,7 +3,7 @@ import { Action, ActionVersionsResponse, ActionsSearchParams, ActionsSearchRespo
 import { Context, Effect, Schema } from "effect";
 
 //#region src/services/ActionsService.d.ts
-declare const ActionsService_base: Context.TagClass<ActionsService, "ActionsService", {
+declare const ActionsService_base: Context.ServiceClass<ActionsService, "ActionsService", {
   readonly get: (id: string, options?: {
     includeReferences?: boolean;
   }) => Effect.Effect<Action, ActionNotFoundError | ServiceError>;

package/dist/src/services/ActionsService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/ActionsService.ts
-var ActionsService = class extends Context.Tag("ActionsService")() {};
+var ActionsService = class extends Context.Service()("ActionsService") {};
 
 //#endregion
 export { ActionsService };

package/dist/src/services/AdaptersService.d.ts

@@ -4,7 +4,7 @@ import { CreateAdapterParams } from "../schemas/adapters.js";
 import { Context, Effect } from "effect";
 
 //#region src/services/AdaptersService.d.ts
-declare const AdaptersService_base: Context.TagClass<AdaptersService, "AdaptersService", {
+declare const AdaptersService_base: Context.ServiceClass<AdaptersService, "AdaptersService", {
   readonly get: (id: string) => Effect.Effect<Action, ActionNotFoundError | ServiceError>;
   readonly create: (params: CreateAdapterParams) => Effect.Effect<CreateActionResponse, ServiceError>;
   readonly updateMetadata: (id: string, params: UpdateActionMetadataParams) => Effect.Effect<void, ActionNotFoundError | ServiceError>;

package/dist/src/services/AdaptersService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/AdaptersService.ts
-var AdaptersService = class extends Context.Tag("AdaptersService")() {};
+var AdaptersService = class extends Context.Service()("AdaptersService") {};
 
 //#endregion
 export { AdaptersService };

package/dist/src/services/AgentSafesService.d.ts

@@ -4,7 +4,7 @@ import { AgentSafe, AgentSafeMetadata, EditAgentSafeMetadataParams, SetSafePropo
 import { Context, Effect } from "effect";
 
 //#region src/services/AgentSafesService.d.ts
-declare const AgentSafesService_base: Context.TagClass<AgentSafesService, "AgentSafesService", {
+declare const AgentSafesService_base: Context.ServiceClass<AgentSafesService, "AgentSafesService", {
   readonly getAgentSafe: (blockchain: BlockchainType, safeAddress: EvmAddressType) => Effect.Effect<AgentSafe, ServiceError>;
   readonly setSafeProposer: (blockchain: BlockchainType, safeAddress: EvmAddressType, params: SetSafeProposerParams) => Effect.Effect<SetSafeProposerResponse, ServiceError>;
   readonly editAgentSafeMetadata: (blockchain: BlockchainType, safeAddress: EvmAddressType, params: EditAgentSafeMetadataParams) => Effect.Effect<AgentSafeMetadata, ServiceError>;

package/dist/src/services/AgentSafesService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/AgentSafesService.ts
-var AgentSafesService = class extends Context.Tag("AgentSafesService")() {};
+var AgentSafesService = class extends Context.Service()("AgentSafesService") {};
 
 //#endregion
 export { AgentSafesService };

package/dist/src/services/AgentWalletsService.d.ts

@@ -4,7 +4,7 @@ import { AgentWalletSafesList, AgentWalletsList, AgentWalletsListParams } from "
 import { Context, Effect } from "effect";
 
 //#region src/services/AgentWalletsService.d.ts
-declare const AgentWalletsService_base: Context.TagClass<AgentWalletsService, "AgentWalletsService", {
+declare const AgentWalletsService_base: Context.ServiceClass<AgentWalletsService, "AgentWalletsService", {
   readonly listAgentWallets: (params?: AgentWalletsListParams) => Effect.Effect<AgentWalletsList, ServiceError>;
   readonly listAgentWalletSafes: (agentWalletAddress: EvmAddressType) => Effect.Effect<AgentWalletSafesList, ServiceError>;
 }>;

package/dist/src/services/AgentWalletsService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/AgentWalletsService.ts
-var AgentWalletsService = class extends Context.Tag("AgentWalletsService")() {};
+var AgentWalletsService = class extends Context.Service()("AgentWalletsService") {};
 
 //#endregion
 export { AgentWalletsService };

package/dist/src/services/AgentWorkflowsService.d.ts

@@ -4,16 +4,16 @@ import { Context, Effect } from "effect";
 
 //#region src/services/AgentWorkflowsService.d.ts
 declare class AgentWorkflowNotFoundError extends Error {
-  readonly workflowId: string;
   readonly _tag = "AgentWorkflowNotFoundError";
+  readonly workflowId: string;
   constructor(workflowId: string);
 }
 declare class AgentWorkflowRunNotFoundError extends Error {
-  readonly runId: string;
   readonly _tag = "AgentWorkflowRunNotFoundError";
+  readonly runId: string;
   constructor(runId: string);
 }
-declare const AgentWorkflowsService_base: Context.TagClass<AgentWorkflowsService, "AgentWorkflowsService", {
+declare const AgentWorkflowsService_base: Context.ServiceClass<AgentWorkflowsService, "AgentWorkflowsService", {
   readonly create: (params: CreateAgentWorkflowParamsType) => Effect.Effect<CreateAgentWorkflowResponseType, ServiceError>;
   readonly list: (params: ListAgentWorkflowsParamsType) => Effect.Effect<ListAgentWorkflowsResponseType, ServiceError>;
   readonly get: (agentWorkflowId: string) => Effect.Effect<AgentWorkflowWithRunsType, AgentWorkflowNotFoundError | ServiceError>;

package/dist/src/services/AgentWorkflowsService.js

@@ -1,21 +1,25 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/AgentWorkflowsService.ts
 var AgentWorkflowNotFoundError = class extends Error {
 	_tag = "AgentWorkflowNotFoundError";
+	workflowId;
 	constructor(workflowId) {
 		super(`Agent workflow ${workflowId} not found`);
 		this.workflowId = workflowId;
+		this.name = "AgentWorkflowNotFoundError";
 	}
 };
 var AgentWorkflowRunNotFoundError = class extends Error {
 	_tag = "AgentWorkflowRunNotFoundError";
+	runId;
 	constructor(runId) {
 		super(`Agent workflow run ${runId} not found`);
 		this.runId = runId;
+		this.name = "AgentWorkflowRunNotFoundError";
 	}
 };
-var AgentWorkflowsService = class extends Context.Tag("AgentWorkflowsService")() {};
+var AgentWorkflowsService = class extends Context.Service()("AgentWorkflowsService") {};
 
 //#endregion
 export { AgentWorkflowNotFoundError, AgentWorkflowRunNotFoundError, AgentWorkflowsService };

package/dist/src/services/AuthService.d.ts

@@ -3,11 +3,11 @@ import { ApiKeyListResponseType, CreatedApiKeyType, TokenResponse, WhoamiRespons
 import { Context, Effect } from "effect";
 
 //#region src/services/AuthService.d.ts
-declare const AuthService_base: Context.TagClass<AuthService, "AuthService", {
-  readonly whoami: () => Effect.Effect<WhoamiResponse, AuthError>;
+declare const AuthService_base: Context.ServiceClass<AuthService, "AuthService", {
+  readonly whoami: Effect.Effect<WhoamiResponse, AuthError>;
   readonly refreshToken: (refreshToken: string, clientId: string) => Effect.Effect<TokenResponse, AuthError>;
   readonly provisionApiKey: (name?: string) => Effect.Effect<CreatedApiKeyType, AuthError>;
-  readonly listApiKeys: () => Effect.Effect<ApiKeyListResponseType, AuthError>;
+  readonly listApiKeys: Effect.Effect<ApiKeyListResponseType, AuthError>;
   readonly revokeApiKey: (keyId: string) => Effect.Effect<void, AuthError>;
 }>;
 declare class AuthService extends AuthService_base {}

package/dist/src/services/AuthService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/AuthService.ts
-var AuthService = class extends Context.Tag("AuthService")() {};
+var AuthService = class extends Context.Service()("AuthService") {};
 
 //#endregion
 export { AuthService };

package/dist/src/services/BookmarksService.d.ts

@@ -3,9 +3,9 @@ import { AddContractBookmarkParams, AddTransactionBookmarkParams, AddWalletBookm
 import { Context, Effect } from "effect";
 
 //#region src/services/BookmarksService.d.ts
-declare const BookmarksService_base: Context.TagClass<BookmarksService, "BookmarksService", {
+declare const BookmarksService_base: Context.ServiceClass<BookmarksService, "BookmarksService", {
   readonly list: (params?: {
-    readonly objectTypes?: ReadonlyArray<BookmarkObjectTypeValue>;
+    readonly objectTypes?: readonly BookmarkObjectTypeValue[];
   }) => Effect.Effect<BookmarksList, ServiceError>;
   readonly addContract: (params: AddContractBookmarkParams) => Effect.Effect<BookmarkResponse, ServiceError>;
   readonly addTransaction: (params: AddTransactionBookmarkParams) => Effect.Effect<BookmarkResponse, ServiceError>;

package/dist/src/services/BookmarksService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/BookmarksService.ts
-var BookmarksService = class extends Context.Tag("BookmarksService")() {};
+var BookmarksService = class extends Context.Service()("BookmarksService") {};
 
 //#endregion
 export { BookmarksService };

package/dist/src/services/CodeBlocksService.d.ts

@@ -3,7 +3,7 @@ import { CodeBlockDefinition, CodeBlockExecuteResponse, CodeBlocksSearchParams,
 import { Context, Effect } from "effect";
 
 //#region src/services/CodeBlocksService.d.ts
-declare const CodeBlocksService_base: Context.TagClass<CodeBlocksService, "CodeBlocksService", {
+declare const CodeBlocksService_base: Context.ServiceClass<CodeBlocksService, "CodeBlocksService", {
   readonly get: (id: string) => Effect.Effect<CodeBlockDefinition, CodeBlockNotFoundError | ServiceError>;
   readonly search: (params: CodeBlocksSearchParams) => Effect.Effect<CodeBlocksSearchResponse, ServiceError>;
   readonly create: (params: CreateCodeBlockParams) => Effect.Effect<CreateCodeBlockResponse, ServiceError>;

package/dist/src/services/CodeBlocksService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/CodeBlocksService.ts
-var CodeBlocksService = class extends Context.Tag("CodeBlocksService")() {};
+var CodeBlocksService = class extends Context.Service()("CodeBlocksService") {};
 
 //#endregion
 export { CodeBlocksService };

package/dist/src/services/CollectionsService.d.ts

@@ -3,7 +3,7 @@ import { Collection, CollectionsSearchParams, CollectionsSearchResponse, CreateC
 import { Context, Effect } from "effect";
 
 //#region src/services/CollectionsService.d.ts
-declare const CollectionsService_base: Context.TagClass<CollectionsService, "CollectionsService", {
+declare const CollectionsService_base: Context.ServiceClass<CollectionsService, "CollectionsService", {
   readonly get: (collectionId: string) => Effect.Effect<Collection, CollectionNotFoundError | ServiceError>;
   readonly search: (params: CollectionsSearchParams) => Effect.Effect<CollectionsSearchResponse, ServiceError>;
   readonly create: (params: CreateCollectionParams) => Effect.Effect<CreateCollectionResponse, ServiceError>;

package/dist/src/services/CollectionsService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/CollectionsService.ts
-var CollectionsService = class extends Context.Tag("CollectionsService")() {};
+var CollectionsService = class extends Context.Service()("CollectionsService") {};
 
 //#endregion
 export { CollectionsService };

package/dist/src/services/ContractsService.d.ts

@@ -5,7 +5,7 @@ import { DeployedContracts } from "../schemas/wallets.js";
 import { Context, Effect } from "effect";
 
 //#region src/services/ContractsService.d.ts
-declare const ContractsService_base: Context.TagClass<ContractsService, "ContractsService", {
+declare const ContractsService_base: Context.ServiceClass<ContractsService, "ContractsService", {
   readonly getMetadata: (address: EvmAddressType, blockchain: BlockchainType) => Effect.Effect<ContractMetadata, ServiceError>;
   readonly diffVersions: (address: EvmAddressType, blockchain: BlockchainType, params?: DiffVersionsParams) => Effect.Effect<ContractDiff, ServiceError>;
   readonly getContractCode: (blockchain: BlockchainType, params: GetContractCodeParams) => Effect.Effect<GetContractCodeResponse, ServiceError>;

package/dist/src/services/ContractsService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/ContractsService.ts
-var ContractsService = class extends Context.Tag("ContractsService")() {};
+var ContractsService = class extends Context.Service()("ContractsService") {};
 
 //#endregion
 export { ContractsService };

package/dist/src/services/DocsService.d.ts

@@ -3,8 +3,8 @@ import { DocContent, DocEntry } from "../schemas/docs.js";
 import { Context, Effect } from "effect";
 
 //#region src/services/DocsService.d.ts
-declare const DocsService_base: Context.TagClass<DocsService, "DocsService", {
-  readonly list: () => Effect.Effect<ReadonlyArray<DocEntry>, ServiceError>;
+declare const DocsService_base: Context.ServiceClass<DocsService, "DocsService", {
+  readonly list: Effect.Effect<readonly DocEntry[], ServiceError>;
   readonly read: (docId: string) => Effect.Effect<DocContent, DocNotFoundError | ServiceError>;
 }>;
 declare class DocsService extends DocsService_base {}

package/dist/src/services/DocsService.js

@@ -1,7 +1,7 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/DocsService.ts
-var DocsService = class extends Context.Tag("DocsService")() {};
+var DocsService = class extends Context.Service()("DocsService") {};
 
 //#endregion
 export { DocsService };

package/dist/src/services/GroupsService.d.ts

@@ -4,15 +4,15 @@ import { Context, Effect } from "effect";
 
 //#region src/services/GroupsService.d.ts
 declare class GroupNotFoundError extends Error {
-  readonly groupId: string;
   readonly _tag = "GroupNotFoundError";
+  readonly groupId: string;
   constructor(groupId: string);
 }
-declare const GroupsService_base: Context.TagClass<GroupsService, "GroupsService", {
+declare const GroupsService_base: Context.ServiceClass<GroupsService, "GroupsService", {
   readonly create: (params: {
     params: CreateGroupParamsType;
   }) => Effect.Effect<CreateGroupResponseType, ServiceError>;
-  readonly list: () => Effect.Effect<ListGroupsResponseType, ServiceError>;
+  readonly list: Effect.Effect<ListGroupsResponseType, ServiceError>;
   readonly get: (params: {
     groupId: string;
   }) => Effect.Effect<GroupDetailsType, GroupNotFoundError | ServiceError>;

package/dist/src/services/GroupsService.js

@@ -1,14 +1,16 @@
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 
 //#region src/services/GroupsService.ts
 var GroupNotFoundError = class extends Error {
 	_tag = "GroupNotFoundError";
+	groupId;
 	constructor(groupId) {
 		super(`Group ${groupId} not found`);
 		this.groupId = groupId;
+		this.name = "GroupNotFoundError";
 	}
 };
-var GroupsService = class extends Context.Tag("GroupsService")() {};
+var GroupsService = class extends Context.Service()("GroupsService") {};
 
 //#endregion
 export { GroupNotFoundError, GroupsService };

package/dist/src/services/HalService.d.ts

@@ -3,7 +3,7 @@ import { EvaluateExistingParams, EvaluateExistingResponse, EvaluateParams, Evalu
 import { Context, Effect } from "effect";
 
 //#region src/services/HalService.d.ts
-declare const HalService_base: Context.TagClass<HalService, "HalService", {
+declare const HalService_base: Context.ServiceClass<HalService, "HalService", {
   readonly evaluate: (params: EvaluateParams) => Effect.Effect<EvaluateResponse, SimulationError | ServiceError>;
   readonly evaluateExisting: (params: EvaluateExistingParams) => Effect.Effect<EvaluateExistingResponse, ActionNotFoundError | SimulationError | ServiceError>;
 }>;