@herd-labs/sdk 0.3.1 → 0.5.0

package/dist/src/schemas/wallets.js

@@ -1,214 +1,275 @@
-import { Blockchain } from "./common.js";
+import { BlockchainSchema } from "./common.js";
 import { Schema } from "effect";
 
 //#region src/schemas/wallets.ts
-var WalletBalance = class extends Schema.Class("WalletBalance")({
+const WalletBalanceSchema = Schema.Struct({
 	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)
-}) {};
-var Erc7702Delegation = class extends Schema.Class("Erc7702Delegation")({
+	logoUrl: Schema.NullOr(Schema.String),
+	symbol: Schema.NullOr(Schema.String),
+	valueUsd: Schema.NullOr(Schema.Number)
+});
+const Erc7702DelegationSchema = Schema.Struct({
 	address: Schema.String,
 	contractName: Schema.String,
 	functions: Schema.Array(Schema.String)
-}) {};
-var MultisigSigner = class extends Schema.Class("MultisigSigner")({
+});
+const MultisigSignerSchema = Schema.Struct({
 	address: Schema.String,
 	isContract: Schema.Boolean
-}) {};
-var PendingTransaction = class extends Schema.Class("PendingTransaction")({
-	safeTxHash: Schema.String,
-	to: Schema.String,
-	value: Schema.String,
+});
+const PendingTransactionSchema = Schema.Struct({
+	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))
-}) {};
-var MultisigDetails = class extends Schema.Class("MultisigDetails")({
-	threshold: Schema.Number,
-	signers: Schema.Array(MultisigSigner),
-	pendingTransactions: Schema.Array(PendingTransaction)
-}) {};
-var WalletOverview = class extends Schema.Class("WalletOverview")({
-	walletAddress: Schema.String,
-	blockchain: Blockchain,
-	walletType: Schema.Literal("eoa", "erc7702", "erc4337", "multisig", "contract"),
-	implementationAddress: Schema.optional(Schema.String),
-	erc7702Delegation: Schema.optional(Erc7702Delegation),
-	multisigDetails: Schema.optional(MultisigDetails),
-	totalTransactionCount: Schema.Number,
+	safeTxHash: Schema.String,
+	submissionDate: Schema.optional(Schema.String),
+	to: Schema.String,
+	value: Schema.String
+});
+const MultisigDetailsSchema = Schema.Struct({
+	pendingTransactions: Schema.Array(PendingTransactionSchema),
+	signers: Schema.Array(MultisigSignerSchema),
+	threshold: Schema.Number
+});
+const WalletOverviewSchema = Schema.Struct({
+	balances: Schema.Array(WalletBalanceSchema),
+	blockchain: BlockchainSchema,
 	earliestTx: Schema.NullOr(Schema.Number),
+	erc7702Delegation: Schema.optional(Erc7702DelegationSchema),
+	implementationAddress: Schema.optional(Schema.String),
+	multisigDetails: Schema.optional(MultisigDetailsSchema),
 	totalDeployedContractsCount: Schema.Number,
-	balances: Schema.Array(WalletBalance)
-}) {};
-var TokenBalanceInfo = class extends Schema.Class("TokenBalanceInfo")({
-	raw: Schema.String,
+	totalTransactionCount: Schema.Number,
+	walletAddress: Schema.String,
+	walletType: Schema.Literals([
+		"eoa",
+		"erc7702",
+		"erc4337",
+		"multisig",
+		"contract"
+	])
+});
+const TokenTypeSchema = Schema.Literals([
+	"ERC20",
+	"ERC721",
+	"ERC1155"
+]);
+const Erc20BalanceInfoSchema = Schema.Struct({
+	tokenType: Schema.Literal("ERC20"),
+	decimals: Schema.NullOr(Schema.Number),
 	formatted: Schema.String,
+	raw: Schema.String,
+	symbol: Schema.NullOr(Schema.String)
+});
+const Erc721BalanceInfoSchema = Schema.Struct({
+	tokenType: Schema.Literal("ERC721"),
+	count: Schema.String,
+	symbol: Schema.NullOr(Schema.String)
+});
+const Erc1155BalanceInfoSchema = Schema.Struct({
+	tokenType: Schema.Literal("ERC1155"),
 	symbol: Schema.NullOr(Schema.String),
-	decimals: Schema.NullOr(Schema.Number)
-}) {};
-var TokenTransfer = class extends Schema.Class("TokenTransfer")({
-	txHash: Schema.String,
+	holdings: Schema.Array(Schema.Struct({
+		amount: Schema.String,
+		tokenId: Schema.String
+	}))
+});
+const TokenBalanceInfoSchema = Schema.Union([
+	Erc20BalanceInfoSchema,
+	Erc721BalanceInfoSchema,
+	Erc1155BalanceInfoSchema
+]);
+const TokenTransferBase = Schema.Struct({
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	blockTimestampUtc: Schema.String,
-	blockNumber: Schema.Number,
-	logIndex: Schema.Number,
+	direction: Schema.Literals(["in", "out"]),
 	fromAddress: Schema.String,
+	logIndex: Schema.Number,
 	toAddress: Schema.String,
+	txHash: Schema.String
+});
+const Erc20TransferSchema = Schema.Struct({
+	...TokenTransferBase.fields,
+	tokenType: Schema.Literal("ERC20"),
 	amount: Schema.String,
-	formattedAmount: Schema.String,
-	direction: Schema.Literal("in", "out")
-}) {};
-var TokenActivityPagination = class extends Schema.Class("TokenActivityPagination")({
+	formattedAmount: Schema.String
+});
+const Erc721TransferSchema = Schema.Struct({
+	...TokenTransferBase.fields,
+	tokenType: Schema.Literal("ERC721"),
+	tokenId: Schema.String
+});
+const Erc1155TransferSchema = Schema.Struct({
+	...TokenTransferBase.fields,
+	tokenType: Schema.Literal("ERC1155"),
+	tokenId: Schema.String,
+	amount: Schema.String
+});
+const TokenTransferSchema = Schema.Union([
+	Erc20TransferSchema,
+	Erc721TransferSchema,
+	Erc1155TransferSchema
+]);
+const TokenActivityPaginationSchema = Schema.Struct({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
-}) {};
-var TokenActivity = class extends Schema.Class("TokenActivity")({
+	pageSize: Schema.Number
+});
+const TokenActivitySchema = Schema.Struct({
+	balance: TokenBalanceInfoSchema,
+	blockchain: BlockchainSchema,
 	holderAddress: Schema.String,
+	pagination: TokenActivityPaginationSchema,
 	tokenAddress: Schema.String,
-	blockchain: Blockchain,
-	balance: TokenBalanceInfo,
-	transfers: Schema.Array(TokenTransfer),
-	pagination: TokenActivityPagination
-}) {};
-var WalletTxCall = class extends Schema.Class("WalletTxCall")({
+	tokenType: TokenTypeSchema,
+	transfers: Schema.Array(TokenTransferSchema)
+});
+const WalletTxCallSchema = Schema.Struct({
 	callee: Schema.String,
-	functionSignature: Schema.String,
-	functionName: Schema.String,
 	contractName: Schema.NullOr(Schema.String),
-	entityLabel: Schema.NullOr(Schema.String)
-}) {};
-var WalletTxActionExecution = class extends Schema.Class("WalletTxActionExecution")({
+	entityLabel: Schema.NullOr(Schema.String),
+	functionName: Schema.String,
+	functionSignature: Schema.String
+});
+const WalletTxActionExecutionSchema = Schema.Struct({
 	actionId: Schema.String,
-	versionId: Schema.String,
 	actionName: Schema.String,
-	executionId: Schema.String
-}) {};
-var WalletTxTransfer = class extends Schema.Class("WalletTxTransfer")({
-	txHash: Schema.String,
-	blockNumber: Schema.Number,
-	tokenAddress: Schema.String,
-	fromAddress: Schema.String,
-	toAddress: Schema.String,
+	executionId: Schema.String,
+	versionId: Schema.String
+});
+const WalletTxTransferSchema = Schema.Struct({
 	amount: Schema.Number,
+	blockNumber: Schema.Number,
 	blockTimestamp: Schema.Number,
 	chainId: Schema.Number,
-	tokenId: Schema.Number,
-	tokenDecimals: Schema.Number,
-	tokenName: Schema.String,
-	tokenSymbol: Schema.String,
-	tokenPriceUsd: Schema.Number,
-	tokenLogoUrl: Schema.String,
-	tokenType: Schema.Literal("NATIVE", "ERC20", "ERC721", "ERC1155"),
+	fromAddress: Schema.String,
 	fromAddressIsContract: Schema.Boolean,
-	toAddressIsContract: Schema.Boolean,
 	fromEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
-	toEntityLabel: Schema.optional(Schema.NullOr(Schema.String))
-}) {};
-var WalletTxBalanceChange = class extends Schema.Class("WalletTxBalanceChange")({
-	txHash: Schema.optional(Schema.String),
-	blockNumber: Schema.Number,
+	toAddress: Schema.String,
+	toAddressIsContract: Schema.Boolean,
+	toEntityLabel: Schema.optional(Schema.NullOr(Schema.String)),
 	tokenAddress: Schema.String,
-	holderAddress: Schema.String,
-	holderIsContract: Schema.Boolean,
+	tokenDecimals: Schema.Number,
+	tokenId: Schema.Number,
+	tokenLogoUrl: Schema.String,
+	tokenName: Schema.String,
+	tokenPriceUsd: Schema.Number,
+	tokenSymbol: Schema.String,
+	tokenType: Schema.Literals([
+		"NATIVE",
+		"ERC20",
+		"ERC721",
+		"ERC1155"
+	]),
+	txHash: Schema.String
+});
+const WalletTxBalanceChangeSchema = Schema.Struct({
 	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)
-}) {};
-var WalletTransaction = class extends Schema.Class("WalletTransaction")({
-	txHash: Schema.String,
+	tokenSymbol: Schema.String,
+	tokenType: Schema.Literals([
+		"NATIVE",
+		"ERC20",
+		"ERC721",
+		"ERC1155"
+	]),
+	transfers: Schema.Array(WalletTxTransferSchema),
+	txHash: Schema.optional(Schema.String)
+});
+const WalletTransactionSchema = Schema.Struct({
+	actionExecution: Schema.optional(WalletTxActionExecutionSchema),
+	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),
+	calls: Schema.Array(WalletTxCallSchema),
 	createdContracts: Schema.Array(Schema.Struct({
 		address: Schema.String,
 		contractName: Schema.NullOr(Schema.String),
 		entityLabel: Schema.NullOr(Schema.String)
 	})),
-	actionExecution: Schema.optional(WalletTxActionExecution)
-}) {};
-var TransactionActivityPagination = class extends Schema.Class("TransactionActivityPagination")({
+	errorMessage: Schema.optional(Schema.String),
+	success: Schema.Boolean,
+	txHash: Schema.String,
+	walletBalanceChanges: Schema.Array(WalletTxBalanceChangeSchema)
+});
+const TransactionActivityPaginationSchema = Schema.Struct({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
-}) {};
-var TransactionActivity = class extends Schema.Class("TransactionActivity")({
+	pageSize: Schema.Number
+});
+const TransactionActivitySchema = Schema.Struct({
+	blockchain: BlockchainSchema,
+	earliestTx: Schema.NullOr(Schema.Number),
 	fromAddress: Schema.String,
-	blockchain: Blockchain,
+	pagination: TransactionActivityPaginationSchema,
 	toAddressesFilter: Schema.optional(Schema.Array(Schema.String)),
 	totalTransactionCount: Schema.Number,
-	earliestTx: Schema.NullOr(Schema.Number),
-	transactions: Schema.Array(WalletTransaction),
-	pagination: TransactionActivityPagination
-}) {};
-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),
+	transactions: Schema.Array(WalletTransactionSchema)
+});
+const DeployedContractSchema = Schema.Struct({
 	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)
-}) {};
-var DeployedContractsPagination = class extends Schema.Class("DeployedContractsPagination")({
+	factoryName: Schema.NullOr(Schema.String),
+	symbol: Schema.NullOr(Schema.String)
+});
+const DeployedContractsPaginationSchema = Schema.Struct({
+	hasMore: Schema.Boolean,
 	page: Schema.Number,
-	pageSize: Schema.Number,
-	hasMore: Schema.Boolean
-}) {};
-var DeployedContracts = class extends Schema.Class("DeployedContracts")({
+	pageSize: Schema.Number
+});
+const DeployedContractsSchema = Schema.Struct({
+	blockchain: BlockchainSchema,
+	deployedContracts: Schema.Array(DeployedContractSchema),
 	deployerAddress: Schema.String,
-	blockchain: Blockchain,
 	isEOA: Schema.Boolean,
-	totalDeployedContractsCount: Schema.Number,
-	deployedContracts: Schema.Array(DeployedContract),
-	pagination: DeployedContractsPagination
-}) {};
-var TokenActivityParams = class extends Schema.Class("TokenActivityParams")({
-	page: Schema.optional(Schema.Number),
-	beforeTimestamp: Schema.optional(Schema.Number),
+	pagination: DeployedContractsPaginationSchema,
+	totalDeployedContractsCount: Schema.Number
+});
+const TokenActivityParamsSchema = Schema.Struct({
+	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")({
-	blockchain: Blockchain,
-	fromAddress: Schema.optional(Schema.String),
-	toAddresses: Schema.optional(Schema.Array(Schema.String)),
-	page: Schema.optional(Schema.Number),
-	beforeTimestamp: Schema.optional(Schema.Number),
+const TransactionActivityQuerySchema = Schema.Struct({
+	afterBlocknumber: Schema.optional(Schema.Number),
 	afterTimestamp: Schema.optional(Schema.Number),
 	beforeBlocknumber: Schema.optional(Schema.Number),
-	afterBlocknumber: Schema.optional(Schema.Number),
-	successOnly: Schema.optional(Schema.Boolean)
-}) {};
+	beforeTimestamp: Schema.optional(Schema.Number),
+	blockchain: BlockchainSchema,
+	fromAddress: Schema.optional(Schema.String),
+	page: Schema.optional(Schema.Number),
+	successOnly: Schema.optional(Schema.Boolean),
+	toAddresses: Schema.optional(Schema.Array(Schema.String))
+});
 
 //#endregion
-export { DeployedContract, DeployedContracts, DeployedContractsPagination, Erc7702Delegation, MultisigDetails, MultisigSigner, PendingTransaction, TokenActivity, TokenActivityPagination, TokenActivityParams, TokenBalanceInfo, TokenTransfer, TransactionActivity, TransactionActivityPagination, TransactionActivityQuery, WalletBalance, WalletOverview, WalletTransaction, WalletTxActionExecution, WalletTxBalanceChange, WalletTxCall, WalletTxTransfer };
+export { DeployedContractSchema, DeployedContractsPaginationSchema, DeployedContractsSchema, Erc1155BalanceInfoSchema, Erc1155TransferSchema, Erc20BalanceInfoSchema, Erc20TransferSchema, Erc721BalanceInfoSchema, Erc721TransferSchema, Erc7702DelegationSchema, MultisigDetailsSchema, MultisigSignerSchema, PendingTransactionSchema, TokenActivityPaginationSchema, TokenActivityParamsSchema, TokenActivitySchema, TokenBalanceInfoSchema, TokenTransferSchema, TokenTypeSchema, TransactionActivityPaginationSchema, TransactionActivityQuerySchema, TransactionActivitySchema, WalletBalanceSchema, WalletOverviewSchema, WalletTransactionSchema, WalletTxActionExecutionSchema, WalletTxBalanceChangeSchema, WalletTxCallSchema, WalletTxTransferSchema };

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

@@ -1,15 +1,15 @@
 import { ActionNotFoundError, ServiceError } from "../errors.js";
-import { Action, ActionVersionsResponse, ActionsSearchParams, ActionsSearchResponse, CreateActionParams, CreateActionResponse, GetActionVersionsParams, PublishExpressionParams, PublishExpressionResponse, RelatedAdaptersResponse, RelatedAdaptersSearchParams, UpdateActionMetadataParams, UpdateExpressionParams } from "../schemas/actions.js";
+import { Action, ActionVersionsResponse, ActionsSearchParams, ActionsSearchResponse, CreateActionParams, CreateActionResponse, GetActionVersionsParams, PublishExpressionParams, PublishExpressionResponse, RelatedAdaptersResponseSchema, RelatedAdaptersSearchParams, UpdateActionMetadataParams, UpdateExpressionParams } from "../schemas/actions.js";
 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>;
   readonly getVersions: (params: GetActionVersionsParams) => Effect.Effect<ActionVersionsResponse, ServiceError>;
   readonly search: (params: ActionsSearchParams) => Effect.Effect<ActionsSearchResponse, ServiceError>;
-  readonly searchRelatedAdapters: (params: RelatedAdaptersSearchParams) => Effect.Effect<Schema.Schema.Type<typeof RelatedAdaptersResponse>, ServiceError>;
+  readonly searchRelatedAdapters: (params: RelatedAdaptersSearchParams) => Effect.Effect<Schema.Schema.Type<typeof RelatedAdaptersResponseSchema>, ServiceError>;
   readonly create: (params: CreateActionParams) => Effect.Effect<CreateActionResponse, ServiceError>;
   readonly updateMetadata: (id: string, params: UpdateActionMetadataParams) => Effect.Effect<void, ActionNotFoundError | ServiceError>;
   readonly updateExpression: (id: string, expressionId: string, params: UpdateExpressionParams) => Effect.Effect<void, 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

@@ -1,13 +1,13 @@
 import { ServiceError } from "../errors.js";
-import { BlockchainType, EvmAddressType } from "../schemas/common.js";
+import { Blockchain, EvmAddress } from "../schemas/common.js";
 import { AgentSafe, AgentSafeMetadata, EditAgentSafeMetadataParams, SetSafeProposerParams, SetSafeProposerResponse } from "../schemas/agent-wallets.js";
 import { Context, Effect } from "effect";
 
 //#region src/services/AgentSafesService.d.ts
-declare const AgentSafesService_base: Context.TagClass<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>;
+declare const AgentSafesService_base: Context.ServiceClass<AgentSafesService, "AgentSafesService", {
+  readonly getAgentSafe: (blockchain: Blockchain, safeAddress: EvmAddress) => Effect.Effect<AgentSafe, ServiceError>;
+  readonly setSafeProposer: (blockchain: Blockchain, safeAddress: EvmAddress, params: SetSafeProposerParams) => Effect.Effect<SetSafeProposerResponse, ServiceError>;
+  readonly editAgentSafeMetadata: (blockchain: Blockchain, safeAddress: EvmAddress, params: EditAgentSafeMetadataParams) => Effect.Effect<AgentSafeMetadata, ServiceError>;
 }>;
 declare class AgentSafesService extends AgentSafesService_base {}
 //#endregion

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

@@ -1,12 +1,12 @@
 import { ServiceError } from "../errors.js";
-import { EvmAddressType } from "../schemas/common.js";
+import { EvmAddress } from "../schemas/common.js";
 import { AgentWalletSafesList, AgentWalletsList, AgentWalletsListParams } from "../schemas/agent-wallets.js";
 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>;
+  readonly listAgentWalletSafes: (agentWalletAddress: EvmAddress) => Effect.Effect<AgentWalletSafesList, ServiceError>;
 }>;
 declare class AgentWalletsService extends AgentWalletsService_base {}
 //#endregion

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

@@ -1,26 +1,26 @@
 import { ServiceError } from "../errors.js";
-import { AgentWorkflowWithRunsType, CreateAgentWorkflowParamsType, CreateAgentWorkflowResponseType, CreateAgentWorkflowRunParamsType, CreateAgentWorkflowRunResponseType, ExecuteSafeTxParamsType, ExecuteSafeTxResponseType, ListAgentWorkflowsParamsType, ListAgentWorkflowsResponseType, PushAgentWorkflowParamsType, PushAgentWorkflowResponseType, SubmitAgentWorkflowDecisionParamsType, SubmitAgentWorkflowDecisionResponseType } from "../schemas/agent-workflows.js";
+import { AgentWorkflowWithRuns, CreateAgentWorkflowParams, CreateAgentWorkflowResponse, CreateAgentWorkflowRunParams, CreateAgentWorkflowRunResponse, ExecuteSafeTxParams, ExecuteSafeTxResponse, ListAgentWorkflowsParams, ListAgentWorkflowsResponse, PushAgentWorkflowParams, PushAgentWorkflowResponse, SubmitAgentWorkflowDecisionParams, SubmitAgentWorkflowDecisionResponse } from "../schemas/agent-workflows.js";
 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", {
-  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>;
-  readonly createRun: (params: CreateAgentWorkflowRunParamsType) => Effect.Effect<CreateAgentWorkflowRunResponseType, AgentWorkflowNotFoundError | ServiceError>;
-  readonly submitDecision: (params: SubmitAgentWorkflowDecisionParamsType) => Effect.Effect<SubmitAgentWorkflowDecisionResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
-  readonly push: (params: PushAgentWorkflowParamsType) => Effect.Effect<PushAgentWorkflowResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
-  readonly executeSafeTx: (params: ExecuteSafeTxParamsType) => Effect.Effect<ExecuteSafeTxResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
+declare const AgentWorkflowsService_base: Context.ServiceClass<AgentWorkflowsService, "AgentWorkflowsService", {
+  readonly create: (params: CreateAgentWorkflowParams) => Effect.Effect<CreateAgentWorkflowResponse, ServiceError>;
+  readonly list: (params: ListAgentWorkflowsParams) => Effect.Effect<ListAgentWorkflowsResponse, ServiceError>;
+  readonly get: (agentWorkflowId: string) => Effect.Effect<AgentWorkflowWithRuns, AgentWorkflowNotFoundError | ServiceError>;
+  readonly createRun: (params: CreateAgentWorkflowRunParams) => Effect.Effect<CreateAgentWorkflowRunResponse, AgentWorkflowNotFoundError | ServiceError>;
+  readonly submitDecision: (params: SubmitAgentWorkflowDecisionParams) => Effect.Effect<SubmitAgentWorkflowDecisionResponse, AgentWorkflowRunNotFoundError | ServiceError>;
+  readonly push: (params: PushAgentWorkflowParams) => Effect.Effect<PushAgentWorkflowResponse, AgentWorkflowRunNotFoundError | ServiceError>;
+  readonly executeSafeTx: (params: ExecuteSafeTxParams) => Effect.Effect<ExecuteSafeTxResponse, AgentWorkflowRunNotFoundError | ServiceError>;
 }>;
 declare class AgentWorkflowsService extends AgentWorkflowsService_base {}
 //#endregion

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

@@ -1,13 +1,13 @@
 import { AuthError } from "../errors.js";
-import { ApiKeyListResponseType, CreatedApiKeyType, TokenResponse, WhoamiResponse } from "../schemas/auth.js";
+import { ApiKeyListResponse, CreatedApiKey, TokenResponse, WhoamiResponse } from "../schemas/auth.js";
 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 provisionApiKey: (name?: string) => Effect.Effect<CreatedApiKey, AuthError>;
+  readonly listApiKeys: Effect.Effect<ApiKeyListResponse, 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 };