@herd-labs/sdk 0.3.1 → 0.4.0

package/dist/src/config.d.ts

@@ -1,18 +1,18 @@
 import { Context, Schema } from "effect";
-import * as effect_Either0 from "effect/Either";
+import * as effect_Result0 from "effect/Result";
 
 //#region src/config.d.ts
-declare const HerdConfigSchema: Schema.EitherFromUnion<Schema.Struct<{
-  baseUrl: typeof Schema.String;
-  apiKey: typeof Schema.String;
+declare const HerdConfigSchema: Schema.Result<Schema.Struct<{
+  readonly apiKey: Schema.String;
+  readonly baseUrl: Schema.String;
 }>, Schema.Struct<{
-  baseUrl: typeof Schema.String;
-  oauthAccessToken: typeof Schema.String;
+  readonly baseUrl: Schema.String;
+  readonly oauthAccessToken: Schema.String;
 }>>;
 type HerdConfigType = typeof HerdConfigSchema.Type;
-declare const HerdConfig_base: Context.TagClass<HerdConfig, "HerdConfig", effect_Either0.Either<{
-  readonly baseUrl: string;
+declare const HerdConfig_base: Context.ServiceClass<HerdConfig, "HerdConfig", effect_Result0.Result<{
   readonly apiKey: string;
+  readonly baseUrl: string;
 }, {
   readonly baseUrl: string;
   readonly oauthAccessToken: string;

package/dist/src/config.js

@@ -1,17 +1,14 @@
 import { Context, Schema } from "effect";
 
 //#region src/config.ts
-const HerdConfigSchema = Schema.EitherFromUnion({
-	left: Schema.Struct({
-		baseUrl: Schema.String,
-		oauthAccessToken: Schema.String
-	}),
-	right: Schema.Struct({
-		baseUrl: Schema.String,
-		apiKey: Schema.String
-	})
-});
-var HerdConfig = class extends Context.Tag("HerdConfig")() {};
+const HerdConfigSchema = Schema.Result(Schema.Struct({
+	apiKey: Schema.String,
+	baseUrl: Schema.String
+}), Schema.Struct({
+	baseUrl: Schema.String,
+	oauthAccessToken: Schema.String
+}));
+var HerdConfig = class extends Context.Service()("HerdConfig") {};
 
 //#endregion
 export { HerdConfig, HerdConfigSchema };

package/dist/src/errors.d.ts

@@ -1,57 +1,42 @@
 import { Schema } from "effect";
+import * as effect_Cause0 from "effect/Cause";
 
 //#region src/errors.d.ts
-declare const ServiceError_base: Schema.TaggedErrorClass<ServiceError, "ServiceError", {
-  readonly _tag: Schema.tag<"ServiceError">;
-} & {
-  message: typeof Schema.String;
-  metadata: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-}>;
+declare const ServiceError_base: Schema.Class<ServiceError, Schema.TaggedStruct<"ServiceError", {
+  readonly message: Schema.String;
+  readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, effect_Cause0.YieldableError>;
 declare class ServiceError extends ServiceError_base {}
-declare const ActionNotFoundError_base: Schema.TaggedErrorClass<ActionNotFoundError, "ActionNotFoundError", {
-  readonly _tag: Schema.tag<"ActionNotFoundError">;
-} & {
-  id: typeof Schema.String;
-}>;
+declare const ActionNotFoundError_base: Schema.Class<ActionNotFoundError, Schema.TaggedStruct<"ActionNotFoundError", {
+  readonly id: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class ActionNotFoundError extends ActionNotFoundError_base {}
-declare const CodeBlockNotFoundError_base: Schema.TaggedErrorClass<CodeBlockNotFoundError, "CodeBlockNotFoundError", {
-  readonly _tag: Schema.tag<"CodeBlockNotFoundError">;
-} & {
-  id: typeof Schema.String;
-}>;
+declare const CodeBlockNotFoundError_base: Schema.Class<CodeBlockNotFoundError, Schema.TaggedStruct<"CodeBlockNotFoundError", {
+  readonly id: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class CodeBlockNotFoundError extends CodeBlockNotFoundError_base {}
-declare const CollectionNotFoundError_base: Schema.TaggedErrorClass<CollectionNotFoundError, "CollectionNotFoundError", {
-  readonly _tag: Schema.tag<"CollectionNotFoundError">;
-} & {
-  id: typeof Schema.String;
-}>;
+declare const CollectionNotFoundError_base: Schema.Class<CollectionNotFoundError, Schema.TaggedStruct<"CollectionNotFoundError", {
+  readonly id: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class CollectionNotFoundError extends CollectionNotFoundError_base {}
-declare const TransactionNotFoundError_base: Schema.TaggedErrorClass<TransactionNotFoundError, "TransactionNotFoundError", {
-  readonly _tag: Schema.tag<"TransactionNotFoundError">;
-} & {
-  txHash: typeof Schema.String;
-  blockchain: typeof Schema.String;
-}>;
+declare const TransactionNotFoundError_base: Schema.Class<TransactionNotFoundError, Schema.TaggedStruct<"TransactionNotFoundError", {
+  readonly blockchain: Schema.String;
+  readonly txHash: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class TransactionNotFoundError extends TransactionNotFoundError_base {}
-declare const DocNotFoundError_base: Schema.TaggedErrorClass<DocNotFoundError, "DocNotFoundError", {
-  readonly _tag: Schema.tag<"DocNotFoundError">;
-} & {
-  docId: typeof Schema.String;
-}>;
+declare const DocNotFoundError_base: Schema.Class<DocNotFoundError, Schema.TaggedStruct<"DocNotFoundError", {
+  readonly docId: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class DocNotFoundError extends DocNotFoundError_base {}
-declare const AuthError_base: Schema.TaggedErrorClass<AuthError, "AuthError", {
-  readonly _tag: Schema.tag<"AuthError">;
-} & {
-  message: typeof Schema.String;
-}>;
+declare const AuthError_base: Schema.Class<AuthError, Schema.TaggedStruct<"AuthError", {
+  readonly message: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class AuthError extends AuthError_base {}
-declare const SimulationError_base: Schema.TaggedErrorClass<SimulationError, "SimulationError", {
-  readonly _tag: Schema.tag<"SimulationError">;
-} & {
-  name: typeof Schema.String;
-  message: typeof Schema.String;
-  hint: Schema.optional<typeof Schema.String>;
-}>;
+declare const SimulationError_base: Schema.Class<SimulationError, Schema.TaggedStruct<"SimulationError", {
+  readonly hint: Schema.optional<Schema.String>;
+  readonly message: Schema.String;
+  readonly name: Schema.String;
+}>, effect_Cause0.YieldableError>;
 declare class SimulationError extends SimulationError_base {}
 declare const ensureServiceError: (fallbackMessage: string) => (error: unknown) => ServiceError;
 //#endregion

package/dist/src/errors.js

@@ -1,26 +1,23 @@
 import { Schema } from "effect";
 
 //#region src/errors.ts
-var ServiceError = class extends Schema.TaggedError()("ServiceError", {
+var ServiceError = class extends Schema.TaggedErrorClass()("ServiceError", {
 	message: Schema.String,
-	metadata: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})
+	metadata: Schema.Record(Schema.String, Schema.Unknown)
 }) {};
-var ActionNotFoundError = class extends Schema.TaggedError()("ActionNotFoundError", { id: Schema.String }) {};
-var CodeBlockNotFoundError = class extends Schema.TaggedError()("CodeBlockNotFoundError", { id: Schema.String }) {};
-var CollectionNotFoundError = class extends Schema.TaggedError()("CollectionNotFoundError", { id: Schema.String }) {};
-var TransactionNotFoundError = class extends Schema.TaggedError()("TransactionNotFoundError", {
-	txHash: Schema.String,
-	blockchain: Schema.String
+var ActionNotFoundError = class extends Schema.TaggedErrorClass()("ActionNotFoundError", { id: Schema.String }) {};
+var CodeBlockNotFoundError = class extends Schema.TaggedErrorClass()("CodeBlockNotFoundError", { id: Schema.String }) {};
+var CollectionNotFoundError = class extends Schema.TaggedErrorClass()("CollectionNotFoundError", { id: Schema.String }) {};
+var TransactionNotFoundError = class extends Schema.TaggedErrorClass()("TransactionNotFoundError", {
+	blockchain: Schema.String,
+	txHash: Schema.String
 }) {};
-var DocNotFoundError = class extends Schema.TaggedError()("DocNotFoundError", { docId: Schema.String }) {};
-var AuthError = class extends Schema.TaggedError()("AuthError", { message: Schema.String }) {};
-var SimulationError = class extends Schema.TaggedError()("SimulationError", {
-	name: Schema.String,
+var DocNotFoundError = class extends Schema.TaggedErrorClass()("DocNotFoundError", { docId: Schema.String }) {};
+var AuthError = class extends Schema.TaggedErrorClass()("AuthError", { message: Schema.String }) {};
+var SimulationError = class extends Schema.TaggedErrorClass()("SimulationError", {
+	hint: Schema.optional(Schema.String),
 	message: Schema.String,
-	hint: Schema.optional(Schema.String)
+	name: Schema.String
 }) {};
 const ensureServiceError = (fallbackMessage) => (error) => {
 	if (error instanceof ServiceError) return error;

package/dist/src/live/ActionsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { ActionsService } from "../services/ActionsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient0 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
 
 //#region src/live/ActionsServiceLive.d.ts
-declare const ActionsServiceLive: Layer.Layer<ActionsService, never, HerdConfig | _effect_platform_HttpClient0.HttpClient>;
+declare const ActionsServiceLive: Layer.Layer<ActionsService, never, HerdConfig | effect_unstable_http_HttpClient0.HttpClient>;
 //#endregion
 export { ActionsServiceLive };

package/dist/src/live/ActionsServiceLive.js

@@ -3,31 +3,31 @@ import { Action, ActionVersionsResponse, ActionsSearchResponse, CreateActionResp
 import { ActionsService } from "../services/ActionsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/ActionsServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new ActionNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const ActionsServiceLive = Layer.effect(ActionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions"), { body: jsonBody({
+			...params,
+			expressionType: "action"
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateActionResponse)), Effect.mapError(ensureServiceError("Failed to create action"))),
+		delete: (id) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete action")), mapNotFound(id)),
 		get: (id, options) => pipe(client.get(makeUrl(baseUrl, `/v1/actions/${id}`, options?.includeReferences === true ? { includeReferences: "true" } : void 0)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Action)), Effect.mapError(ensureServiceError("Failed to get action")), mapNotFound(id)),
 		getVersions: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/versions"), { body: jsonBody({
 			actionIds: params.actionIds,
 			latest: params.latest
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ActionVersionsResponse)), Effect.mapError(ensureServiceError("Failed to get action versions"))),
+		publishExpression: (id, expressionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}/publish`), { body: jsonBody(params ?? {}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishExpressionResponse)), Effect.mapError(ensureServiceError("Failed to publish expression")), mapNotFound(id)),
 		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ActionsSearchResponse)), Effect.mapError(ensureServiceError("Failed to search actions"))),
 		searchRelatedAdapters: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/related-adapters/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(RelatedAdaptersResponse)), Effect.mapError(ensureServiceError("Failed to search related adapters"))),
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions"), { body: jsonBody({
-			...params,
-			expressionType: "action"
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateActionResponse)), Effect.mapError(ensureServiceError("Failed to create action"))),
-		updateMetadata: (id, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/actions/${id}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update action metadata")), mapNotFound(id)),
 		updateExpression: (id, expressionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update expression")), mapNotFound(id)),
-		publishExpression: (id, expressionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}/publish`), { body: jsonBody(params ?? {}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishExpressionResponse)), Effect.mapError(ensureServiceError("Failed to publish expression")), mapNotFound(id)),
-		delete: (id) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete action")), mapNotFound(id))
+		updateMetadata: (id, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/actions/${id}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update action metadata")), mapNotFound(id))
 	};
 }));
 

package/dist/src/live/AdaptersServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { AdaptersService } from "../services/AdaptersService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient0 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient1 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AdaptersServiceLive.d.ts
-declare const AdaptersServiceLive: Layer.Layer<AdaptersService, never, HerdConfig | _effect_platform_HttpClient0.HttpClient>;
+declare const AdaptersServiceLive: Layer.Layer<AdaptersService, never, HerdConfig | effect_unstable_http_HttpClient1.HttpClient>;
 //#endregion
 export { AdaptersServiceLive };

package/dist/src/live/AdaptersServiceLive.js

@@ -3,25 +3,25 @@ import { Action, CreateActionResponse, PublishExpressionResponse } from "../sche
 import { AdaptersService } from "../services/AdaptersService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AdaptersServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new ActionNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const AdaptersServiceLive = Layer.effect(AdaptersService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		get: (id) => pipe(client.get(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Action)), Effect.mapError(ensureServiceError("Failed to get adapter")), mapNotFound(id)),
 		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions"), { body: jsonBody({
 			...params,
 			expressionType: "adapter"
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateActionResponse)), Effect.mapError(ensureServiceError("Failed to create adapter"))),
-		updateMetadata: (id, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/actions/${id}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update adapter metadata")), mapNotFound(id)),
-		updateExpression: (id, expressionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update adapter expression")), mapNotFound(id)),
+		delete: (id) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete adapter")), mapNotFound(id)),
+		get: (id) => pipe(client.get(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Action)), Effect.mapError(ensureServiceError("Failed to get adapter")), mapNotFound(id)),
 		publishExpression: (id, expressionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}/publish`), { body: jsonBody(params ?? {}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishExpressionResponse)), Effect.mapError(ensureServiceError("Failed to publish adapter expression")), mapNotFound(id)),
-		delete: (id) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/${id}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete adapter")), mapNotFound(id))
+		updateExpression: (id, expressionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/${id}/expressions/${expressionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update adapter expression")), mapNotFound(id)),
+		updateMetadata: (id, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/actions/${id}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update adapter metadata")), mapNotFound(id))
 	};
 }));
 

package/dist/src/live/AgentSafesServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { AgentSafesService } from "../services/AgentSafesService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient1 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient2 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AgentSafesServiceLive.d.ts
-declare const AgentSafesServiceLive: Layer.Layer<AgentSafesService, never, HerdConfig | _effect_platform_HttpClient1.HttpClient>;
+declare const AgentSafesServiceLive: Layer.Layer<AgentSafesService, never, HerdConfig | effect_unstable_http_HttpClient2.HttpClient>;
 //#endregion
 export { AgentSafesServiceLive };

package/dist/src/live/AgentSafesServiceLive.js

@@ -3,15 +3,15 @@ import { AgentSafe, AgentSafeMetadata, SetSafeProposerResponse } from "../schema
 import { AgentSafesService } from "../services/AgentSafesService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AgentSafesServiceLive.ts
 const AgentSafesServiceLive = Layer.effect(AgentSafesService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		editAgentSafeMetadata: (blockchain, safeAddress, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/agent-safes/${blockchain}/${safeAddress}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentSafeMetadata)), Effect.mapError(ensureServiceError("Failed to edit agent Safe metadata"))),
 		getAgentSafe: (blockchain, safeAddress) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-safes/${blockchain}/${safeAddress}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentSafe)), Effect.mapError(ensureServiceError("Failed to get agent Safe"))),
-		setSafeProposer: (blockchain, safeAddress, params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-safes/${blockchain}/${safeAddress}/proposers`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SetSafeProposerResponse)), Effect.mapError(ensureServiceError("Failed to set agent Safe proposer"))),
-		editAgentSafeMetadata: (blockchain, safeAddress, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/agent-safes/${blockchain}/${safeAddress}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentSafeMetadata)), Effect.mapError(ensureServiceError("Failed to edit agent Safe metadata")))
+		setSafeProposer: (blockchain, safeAddress, params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-safes/${blockchain}/${safeAddress}/proposers`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SetSafeProposerResponse)), Effect.mapError(ensureServiceError("Failed to set agent Safe proposer")))
 	};
 }));
 

package/dist/src/live/AgentWalletsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { AgentWalletsService } from "../services/AgentWalletsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient11 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AgentWalletsServiceLive.d.ts
-declare const AgentWalletsServiceLive: Layer.Layer<AgentWalletsService, never, HerdConfig | _effect_platform_HttpClient11.HttpClient>;
+declare const AgentWalletsServiceLive: Layer.Layer<AgentWalletsService, never, HerdConfig | effect_unstable_http_HttpClient0.HttpClient>;
 //#endregion
 export { AgentWalletsServiceLive };

package/dist/src/live/AgentWalletsServiceLive.js

@@ -3,14 +3,14 @@ import { AgentWalletSafesList, AgentWalletsList } from "../schemas/agent-wallets
 import { AgentWalletsService } from "../services/AgentWalletsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AgentWalletsServiceLive.ts
 const AgentWalletsServiceLive = Layer.effect(AgentWalletsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		listAgentWallets: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-wallets", { groupId: params?.groupId })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletsList)), Effect.mapError(ensureServiceError("Failed to list agent wallets"))),
-		listAgentWalletSafes: (agentWalletAddress) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-wallets/${agentWalletAddress}/safes`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletSafesList)), Effect.mapError(ensureServiceError("Failed to list agent wallet Safes")))
+		listAgentWalletSafes: (agentWalletAddress) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-wallets/${agentWalletAddress}/safes`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletSafesList)), Effect.mapError(ensureServiceError("Failed to list agent wallet Safes"))),
+		listAgentWallets: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-wallets", { groupId: params?.groupId })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletsList)), Effect.mapError(ensureServiceError("Failed to list agent wallets")))
 	};
 }));
 

package/dist/src/live/AgentWorkflowsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { AgentWorkflowsService } from "../services/AgentWorkflowsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient12 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient3 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AgentWorkflowsServiceLive.d.ts
-declare const AgentWorkflowsServiceLive: Layer.Layer<AgentWorkflowsService, never, HerdConfig | _effect_platform_HttpClient12.HttpClient>;
+declare const AgentWorkflowsServiceLive: Layer.Layer<AgentWorkflowsService, never, HerdConfig | effect_unstable_http_HttpClient3.HttpClient>;
 //#endregion
 export { AgentWorkflowsServiceLive };

package/dist/src/live/AgentWorkflowsServiceLive.js

@@ -3,14 +3,14 @@ import { AgentWorkflowWithRuns, CreateAgentWorkflowResponse, CreateAgentWorkflow
 import { AgentWorkflowNotFoundError, AgentWorkflowRunNotFoundError, AgentWorkflowsService } from "../services/AgentWorkflowsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AgentWorkflowsServiceLive.ts
-const mapWorkflowNotFound = (workflowId) => Effect.catchAll((error) => {
+const mapWorkflowNotFound = (workflowId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new AgentWorkflowNotFoundError(workflowId));
 	return Effect.fail(error);
 });
-const mapRunNotFound = (runId) => Effect.catchAll((error) => {
+const mapRunNotFound = (runId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new AgentWorkflowRunNotFoundError(runId));
 	return Effect.fail(error);
 });
@@ -18,18 +18,18 @@ const AgentWorkflowsServiceLive = Layer.effect(AgentWorkflowsService, Effect.gen
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
 		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/agent-workflows"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowResponse)), Effect.mapError(ensureServiceError("Failed to create agent workflow"))),
-		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-workflows", {
-			groupId: params.groupId,
-			type: params.type
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListAgentWorkflowsResponse)), Effect.mapError(ensureServiceError("Failed to list agent workflows"))),
-		get: (agentWorkflowId) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-workflows/${agentWorkflowId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWorkflowWithRuns)), Effect.mapError(ensureServiceError("Failed to get agent workflow")), mapWorkflowNotFound(agentWorkflowId)),
 		createRun: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/${params.agentWorkflowId}/runs`), { body: jsonBody({
 			outputs: params.outputs,
 			changelog: params.changelog
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowRunResponse)), Effect.mapError(ensureServiceError("Failed to create agent workflow run")), mapWorkflowNotFound(params.agentWorkflowId)),
-		submitDecision: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/decisions`), { body: jsonBody({ decision: params.decision }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SubmitAgentWorkflowDecisionResponse)), Effect.mapError(ensureServiceError("Failed to submit agent workflow decision")), mapRunNotFound(params.agentWorkflowRunId)),
+		executeSafeTx: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push/execute`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ExecuteSafeTxResponse)), Effect.mapError(ensureServiceError("Failed to execute safe transaction")), mapRunNotFound(params.agentWorkflowRunId)),
+		get: (agentWorkflowId) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-workflows/${agentWorkflowId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWorkflowWithRuns)), Effect.mapError(ensureServiceError("Failed to get agent workflow")), mapWorkflowNotFound(agentWorkflowId)),
+		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-workflows", {
+			groupId: params.groupId,
+			type: params.type
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListAgentWorkflowsResponse)), Effect.mapError(ensureServiceError("Failed to list agent workflows"))),
 		push: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PushAgentWorkflowResponse)), Effect.mapError(ensureServiceError("Failed to push agent workflow")), mapRunNotFound(params.agentWorkflowRunId)),
-		executeSafeTx: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push/execute`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ExecuteSafeTxResponse)), Effect.mapError(ensureServiceError("Failed to execute safe transaction")), mapRunNotFound(params.agentWorkflowRunId))
+		submitDecision: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/decisions`), { body: jsonBody({ decision: params.decision }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SubmitAgentWorkflowDecisionResponse)), Effect.mapError(ensureServiceError("Failed to submit agent workflow decision")), mapRunNotFound(params.agentWorkflowRunId))
 	};
 }));
 

package/dist/src/live/AuthServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { AuthService } from "../services/AuthService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient13 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient10 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AuthServiceLive.d.ts
-declare const AuthServiceLive: Layer.Layer<AuthService, never, HerdConfig | _effect_platform_HttpClient13.HttpClient>;
+declare const AuthServiceLive: Layer.Layer<AuthService, never, HerdConfig | effect_unstable_http_HttpClient10.HttpClient>;
 //#endregion
 export { AuthServiceLive };

package/dist/src/live/AuthServiceLive.js

@@ -3,22 +3,22 @@ import { ApiKeyListResponse, CreatedApiKey, TokenResponse, WhoamiResponse } from
 import { AuthService } from "../services/AuthService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl, urlEncodedBody } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AuthServiceLive.ts
 const AuthServiceLive = Layer.effect(AuthService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		whoami: () => pipe(client.get(makeUrl(baseUrl, "/v1/users/me")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WhoamiResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		listApiKeys: pipe(client.get(makeUrl(baseUrl, "/v1/api-keys")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ApiKeyListResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		provisionApiKey: (name) => pipe(client.post(makeUrl(baseUrl, "/v1/api-keys"), { body: jsonBody({ name }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreatedApiKey)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
 		refreshToken: (refreshToken, clientId) => pipe(client.post(makeUrl(baseUrl, "/api/auth/oauth2/token"), { body: urlEncodedBody({
 			grant_type: "refresh_token",
 			refresh_token: refreshToken,
 			client_id: clientId,
 			resource: baseUrl
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		provisionApiKey: (name) => pipe(client.post(makeUrl(baseUrl, "/v1/api-keys"), { body: jsonBody({ name }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreatedApiKey)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		listApiKeys: () => pipe(client.get(makeUrl(baseUrl, "/v1/api-keys")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ApiKeyListResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		revokeApiKey: (keyId) => pipe(client.del(makeUrl(baseUrl, `/v1/api-keys/${keyId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError((error) => new AuthError({ message: String(error) })))
+		revokeApiKey: (keyId) => pipe(client.del(makeUrl(baseUrl, `/v1/api-keys/${keyId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		whoami: pipe(client.get(makeUrl(baseUrl, "/v1/users/me")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WhoamiResponse)), Effect.mapError((error) => new AuthError({ message: String(error) })))
 	};
 }));
 

package/dist/src/live/BookmarksServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { BookmarksService } from "../services/BookmarksService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient2 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient6 from "effect/unstable/http/HttpClient";
 
 //#region src/live/BookmarksServiceLive.d.ts
-declare const BookmarksServiceLive: Layer.Layer<BookmarksService, never, HerdConfig | _effect_platform_HttpClient2.HttpClient>;
+declare const BookmarksServiceLive: Layer.Layer<BookmarksService, never, HerdConfig | effect_unstable_http_HttpClient6.HttpClient>;
 //#endregion
 export { BookmarksServiceLive };

package/dist/src/live/BookmarksServiceLive.js

@@ -3,13 +3,12 @@ import { BookmarkResponse, BookmarksList } from "../schemas/bookmarks.js";
 import { BookmarksService } from "../services/BookmarksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/BookmarksServiceLive.ts
 const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksList)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
 		addContract: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "contract",
 			contractAddress: params.address,
@@ -18,7 +17,7 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedFunctions: [],
 				savedEvents: []
 			},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
+			...params.label === void 0 ? {} : { userLabel: params.label }
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add contract bookmark"))),
 		addTransaction: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "transaction",
@@ -28,29 +27,30 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedFunctions: [],
 				savedEvents: []
 			},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
+			...params.label === void 0 ? {} : { userLabel: params.label }
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add transaction bookmark"))),
 		addWallet: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "wallet",
 			walletAddress: params.address,
 			details: {},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
+			...params.label === void 0 ? {} : { userLabel: params.label }
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add wallet bookmark"))),
-		updateLabel: (params) => pipe(client.patch(makeUrl(baseUrl, "/v1/bookmarks/label"), { body: jsonBody({
+		delete: (params) => pipe(client.del(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: params.objectType,
-			...params.address !== void 0 ? { contractAddress: params.address } : {},
+			...params.address === void 0 ? {} : { contractAddress: params.address },
 			...params.address !== void 0 && params.objectType === "wallet" ? { walletAddress: params.address } : {},
-			...params.txHash !== void 0 ? { transactionHash: params.txHash } : {},
-			...params.blockchain !== void 0 ? { blockchain: params.blockchain } : {},
-			userLabel: params.label
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to update bookmark label"))),
-		delete: (params) => pipe(client.del(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
+			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
+			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain }
+		}) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete bookmark"))),
+		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksList)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
+		updateLabel: (params) => pipe(client.patch(makeUrl(baseUrl, "/v1/bookmarks/label"), { body: jsonBody({
 			objectType: params.objectType,
-			...params.address !== void 0 ? { contractAddress: params.address } : {},
+			...params.address === void 0 ? {} : { contractAddress: params.address },
 			...params.address !== void 0 && params.objectType === "wallet" ? { walletAddress: params.address } : {},
-			...params.txHash !== void 0 ? { transactionHash: params.txHash } : {},
-			...params.blockchain !== void 0 ? { blockchain: params.blockchain } : {}
-		}) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete bookmark")))
+			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
+			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain },
+			userLabel: params.label
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to update bookmark label")))
 	};
 }));
 

package/dist/src/live/CodeBlocksServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient9 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient8 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CodeBlocksServiceLive.d.ts
-declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfig | _effect_platform_HttpClient9.HttpClient>;
+declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfig | effect_unstable_http_HttpClient8.HttpClient>;
 //#endregion
 export { CodeBlocksServiceLive };