@homeflare/alchemy 0.52.0 → 0.53.0

package/dist/litellm/index.js

@@ -1557,7 +1557,7 @@ var accessGroupHandlers = {
   list: () => Effect20.succeed([])
 };
 var LiteLLMAccessGroupProvider = () => Provider5.effect(LiteLLMAccessGroup, Effect20.succeed(LiteLLMAccessGroup.Provider.of(accessGroupHandlers)));
-// src/litellm/policy-attachment.ts
+// src/litellm/marketplace-plugin.ts
 import { Resource as Resource6 } from "alchemy";
 import { Unowned as Unowned7 } from "alchemy/AdoptPolicy";
 import { isResolved as isResolved6 } from "alchemy/Diff";
@@ -1565,9 +1565,207 @@ import * as Provider6 from "alchemy/Provider";
 import * as Effect22 from "effect/Effect";
 import * as Predicate7 from "effect/Predicate";
 
+// src/litellm/marketplace-form.ts
+var TEXT = ["description", "version", "domain", "namespace", "category", "homepage"];
+var SOURCE_KINDS = new Set(["github", "url", "git-subdir", "archive"]);
+var firstProblem4 = (props) => {
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(String(props.pluginName))) {
+    return "`pluginName` must be kebab-case (lowercase letters, digits and single hyphens)";
+  }
+  const source = props.source;
+  if (source === undefined || isBlank3(source["source"])) {
+    return "`source` needs a `source` kind (github, url, git-subdir or archive)";
+  }
+  if (!SOURCE_KINDS.has(String(source["source"]))) {
+    return `\`source.source\` must be github, url, git-subdir or archive`;
+  }
+  for (const [key, value5] of Object.entries(source)) {
+    if (isBlank3(key) || isBlank3(value5))
+      return `\`source.${key}\` is blank`;
+  }
+  for (const field of TEXT) {
+    if (props[field] !== undefined && isBlank3(props[field])) {
+      return `\`${field}\` is blank; leave it out to keep the live text`;
+    }
+  }
+  if (props.author !== undefined && isBlank3(props.author.name))
+    return "`author.name` is blank";
+  const bad = firstBadEntry(props.keywords ?? []);
+  if (bad !== undefined)
+    return `\`keywords\` has a blank or padded entry (${JSON.stringify(bad)})`;
+  const twice = firstDuplicate(props.keywords ?? []);
+  if (twice !== undefined)
+    return `\`keywords\` lists ${JSON.stringify(twice)} twice`;
+  return;
+};
+var sourceOf = (value5) => Object.fromEntries(Object.entries(asRow(value5) ?? {}).filter((entry) => typeof entry[1] === "string"));
+var toAttributes6 = (value5) => {
+  const row = asRow(value5);
+  if (row === undefined)
+    return;
+  const pluginId = row["id"];
+  const pluginName = row["name"];
+  if (typeof pluginId !== "string" || typeof pluginName !== "string")
+    return;
+  const author = asRow(row["author"]);
+  return {
+    author: author !== undefined && typeof author["name"] === "string" ? { email: stringOrNull(author["email"]), name: author["name"] } : null,
+    category: stringOrNull(row["category"]),
+    description: stringOrNull(row["description"]),
+    domain: stringOrNull(row["domain"]),
+    enabled: row["enabled"] === true,
+    homepage: stringOrNull(row["homepage"]),
+    keywords: canonical2(stringsOf(row["keywords"])),
+    namespace: stringOrNull(row["namespace"]),
+    pluginId,
+    pluginName,
+    source: sourceOf(row["source"]),
+    version: stringOrNull(row["version"])
+  };
+};
+var sameSource = (left, right) => {
+  const a = Object.entries(left).sort(([x], [y]) => x.localeCompare(y));
+  const b = Object.entries(right).sort(([x], [y]) => x.localeCompare(y));
+  return a.length === b.length && a.every(([k, v], i) => k === b[i]?.[0] && v === b[i]?.[1]);
+};
+var differing5 = (live, props) => {
+  const fields = [];
+  if (!sameSource(live.source, props.source))
+    fields.push("source");
+  for (const field of TEXT) {
+    if (props[field] !== undefined && live[field] !== props[field])
+      fields.push(field);
+  }
+  if (props.keywords !== undefined && !sameSet2(live.keywords, props.keywords)) {
+    fields.push("keywords");
+  }
+  if (props.author !== undefined) {
+    const same = live.author?.name === props.author.name && (props.author.email === undefined || live.author.email === props.author.email);
+    if (!same)
+      fields.push("author");
+  }
+  if (live.enabled !== (props.enabled ?? true))
+    fields.push("enabled");
+  return fields;
+};
+var metadata = (props, live) => {
+  const author = props.author ? { name: props.author.name } : live?.author ? { name: live.author.name } : undefined;
+  if (author !== undefined) {
+    const keep = props.author?.email ?? live?.author?.email;
+    if (keep !== undefined && keep !== null) {
+      author.email = keep;
+    }
+  }
+  const keywords = props.keywords ?? (live?.keywords.length ? live.keywords : undefined);
+  return {
+    ...author === undefined ? {} : { author },
+    ...Object.fromEntries(TEXT.flatMap((field) => {
+      const value5 = props[field] ?? live?.[field] ?? undefined;
+      return value5 === undefined ? [] : [[field, value5]];
+    })),
+    ...keywords === undefined ? {} : { keywords: [...keywords] },
+    source: { ...props.source }
+  };
+};
+var registerBody = (props) => ({
+  ...metadata(props),
+  name: props.pluginName
+});
+var updateBody5 = (props, live) => metadata(props, live);
+
+// src/litellm/marketplace-operations.ts
+import * as cc from "@distilled.cloud/litellm/claude_code_marketplace";
+import * as Effect21 from "effect/Effect";
+var RESOURCE3 = "LiteLLM.ClaudeCodeMarketplacePlugin";
+var listPlugins = () => throughFetch(cc.listPluginsClaudeCodePluginsGet({})).pipe(Effect21.flatMap((response) => {
+  const items = asRow(bodyOf(response))?.["plugins"];
+  const parsed = Array.isArray(items) ? items.map(toAttributes6) : undefined;
+  return parsed !== undefined && parsed.every((row) => row !== undefined) ? Effect21.succeed(parsed) : Effect21.fail(new LitellmRegistryUnreadableError({
+    reason: "no plugins array of rows with an id and a name",
+    resource: RESOURCE3
+  }));
+}));
+var registerPlugin = (body) => throughFetch(cc.registerPluginClaudeCodePluginsPost(body)).pipe(Effect21.asVoid);
+var updatePlugin = (name, body) => throughFetch(cc.updatePluginClaudeCodePluginsPluginNamePut({ ...body, plugin_name: name })).pipe(Effect21.asVoid);
+var setEnabled = (name, enabled) => throughFetch(enabled ? cc.enablePluginClaudeCodePluginsPluginNameEnablePost({ plugin_name: name }) : cc.disablePluginClaudeCodePluginsPluginNameDisablePost({ plugin_name: name })).pipe(Effect21.asVoid);
+var deletePlugin = (name) => throughFetch(cc.deletePluginClaudeCodePluginsPluginNameDelete({ plugin_name: name })).pipe(Effect21.asVoid, Effect21.catch((original) => listPlugins().pipe(Effect21.catch(() => Effect21.fail(original)), Effect21.flatMap((rows) => rows.some((row) => row.pluginName === name) ? Effect21.fail(original) : Effect21.void))));
+
+// src/litellm/marketplace-plugin.ts
+var RESOURCE4 = "LiteLLM.ClaudeCodeMarketplacePlugin";
+var LiteLLMClaudeCodeMarketplacePlugin = Resource6("LiteLLM.ClaudeCodeMarketplacePlugin", { defaultRemovalPolicy: "retain" });
+var isLiteLLMClaudeCodeMarketplacePlugin = (value5) => Predicate7.hasProperty(value5, "Type") && value5.Type === "LiteLLM.ClaudeCodeMarketplacePlugin";
+var locate4 = (rows, props, output) => rows.find((row) => row.pluginName === (output?.pluginName ?? props.pluginName));
+var findNamed = (name) => listPlugins().pipe(Effect22.map((rows) => rows.find((row) => row.pluginName === name)));
+var marketplacePluginHandlers = {
+  read: ({
+    olds,
+    output
+  }) => Effect22.gen(function* () {
+    if (output === undefined) {
+      yield* dieIfInvalid(RESOURCE4, String(olds.pluginName), firstProblem4(olds));
+    }
+    const live = locate4(yield* listPlugins(), olds, output);
+    if (live === undefined)
+      return;
+    return output === undefined ? Unowned7(live) : live;
+  }),
+  diff: ({
+    news,
+    output
+  }) => Effect22.gen(function* () {
+    if (!isResolved6(news))
+      return;
+    yield* failIfInvalid(RESOURCE4, String(news.pluginName), firstProblem4(news));
+    if (output === undefined)
+      return;
+    if (output.pluginName !== news.pluginName)
+      return { action: "replace" };
+    return differing5(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+  }),
+  reconcile: ({
+    news,
+    output
+  }) => Effect22.gen(function* () {
+    yield* failIfInvalid(RESOURCE4, String(news.pluginName), firstProblem4(news));
+    const before = locate4(yield* listPlugins(), news, output);
+    if (before === undefined)
+      yield* registerPlugin(registerBody(news));
+    else if (differing5(before, news).some((field) => field !== "enabled")) {
+      yield* updatePlugin(news.pluginName, updateBody5(news, before));
+    }
+    const written = yield* findNamed(news.pluginName);
+    if (written !== undefined && written.enabled !== (news.enabled ?? true)) {
+      yield* setEnabled(news.pluginName, news.enabled ?? true);
+    }
+    const after = yield* findNamed(news.pluginName);
+    if (after === undefined) {
+      return yield* Effect22.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.pluginName, resource: RESOURCE4 }));
+    }
+    const left = differing5(after, news);
+    if (left.length > 0) {
+      return yield* Effect22.fail(new LitellmRegistryNotConvergedError({
+        fields: left,
+        name: news.pluginName,
+        resource: RESOURCE4
+      }));
+    }
+    return after;
+  }),
+  delete: ({ output }) => deletePlugin(output.pluginName),
+  list: () => Effect22.succeed([])
+};
+var LiteLLMClaudeCodeMarketplacePluginProvider = () => Provider6.effect(LiteLLMClaudeCodeMarketplacePlugin, Effect22.succeed(LiteLLMClaudeCodeMarketplacePlugin.Provider.of(marketplacePluginHandlers)));
+// src/litellm/policy-attachment.ts
+import { Resource as Resource7 } from "alchemy";
+import { Unowned as Unowned8 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved7 } from "alchemy/Diff";
+import * as Provider7 from "alchemy/Provider";
+import * as Effect24 from "effect/Effect";
+import * as Predicate8 from "effect/Predicate";
+
 // src/litellm/policy-attachment-form.ts
 var SELECTORS = ["teams", "keys", "models", "tags"];
-var firstProblem4 = (props) => {
+var firstProblem5 = (props) => {
   if (isBlank3(props.policyName) || props.policyName !== props.policyName.trim()) {
     return "`policyName` must be a non-blank name with no leading or trailing space";
   }
@@ -1590,7 +1788,7 @@ var firstProblem4 = (props) => {
   }
   return;
 };
-var toAttributes6 = (value5) => {
+var toAttributes7 = (value5) => {
   const row = asRow(value5);
   if (row === undefined)
     return;
@@ -1610,7 +1808,7 @@ var toAttributes6 = (value5) => {
   };
 };
 var isConfigRow = (value5) => asRow(value5)?.["definition_location"] === "config";
-var differing5 = (live, props) => {
+var differing6 = (live, props) => {
   const fields = [];
   if (live.policyName !== props.policyName)
     fields.push("policy_name");
@@ -1635,105 +1833,105 @@ var createBody6 = (props) => ({
 
 // src/litellm/policy-attachment-operations.ts
 import * as policies from "@distilled.cloud/litellm/policy_engine";
-import * as Effect21 from "effect/Effect";
-var RESOURCE3 = "LiteLLM.PolicyAttachment";
-var unreadable = (reason) => new LitellmRegistryUnreadableError({ reason, resource: RESOURCE3 });
-var listAttachments = () => throughFetch(policies.listPolicyAttachmentsPoliciesAttachmentsListGet({})).pipe(Effect21.flatMap((response) => {
+import * as Effect23 from "effect/Effect";
+var RESOURCE5 = "LiteLLM.PolicyAttachment";
+var unreadable = (reason) => new LitellmRegistryUnreadableError({ reason, resource: RESOURCE5 });
+var listAttachments = () => throughFetch(policies.listPolicyAttachmentsPoliciesAttachmentsListGet({})).pipe(Effect23.flatMap((response) => {
   const rows = asRow(bodyOf(response))?.["attachments"];
   if (rows === undefined)
-    return Effect21.succeed([]);
+    return Effect23.succeed([]);
   if (!Array.isArray(rows))
-    return Effect21.fail(unreadable("attachments is not an array"));
-  const parsed = rows.filter((row) => !isConfigRow(row)).map(toAttributes6);
-  return parsed.every((each) => each !== undefined) ? Effect21.succeed(parsed) : Effect21.fail(unreadable("an attachment has no id or policy name"));
+    return Effect23.fail(unreadable("attachments is not an array"));
+  const parsed = rows.filter((row) => !isConfigRow(row)).map(toAttributes7);
+  return parsed.every((each) => each !== undefined) ? Effect23.succeed(parsed) : Effect23.fail(unreadable("an attachment has no id or policy name"));
 }));
-var createAttachment = (body) => throughFetch(policies.createPolicyAttachmentPoliciesAttachmentsPost(body)).pipe(Effect21.map((response) => toAttributes6(bodyOf(response))));
+var createAttachment = (body) => throughFetch(policies.createPolicyAttachmentPoliciesAttachmentsPost(body)).pipe(Effect23.map((response) => toAttributes7(bodyOf(response))));
 var deleteAttachment = (attachmentId) => throughFetch(policies.deletePolicyAttachmentPoliciesAttachmentsAttachmentIdDelete({
   attachment_id: attachmentId
-})).pipe(Effect21.asVoid, Effect21.catch((original) => listAttachments().pipe(Effect21.catch(() => Effect21.fail(original)), Effect21.flatMap((rows) => rows.some((row) => row.attachmentId === attachmentId) ? Effect21.fail(original) : Effect21.void))));
+})).pipe(Effect23.asVoid, Effect23.catch((original) => listAttachments().pipe(Effect23.catch(() => Effect23.fail(original)), Effect23.flatMap((rows) => rows.some((row) => row.attachmentId === attachmentId) ? Effect23.fail(original) : Effect23.void))));
 
 // src/litellm/policy-attachment.ts
-var RESOURCE4 = "LiteLLM.PolicyAttachment";
-var LiteLLMPolicyAttachment = Resource6("LiteLLM.PolicyAttachment");
-var isLiteLLMPolicyAttachment = (value5) => Predicate7.hasProperty(value5, "Type") && value5.Type === "LiteLLM.PolicyAttachment";
-var locate4 = (rows, props, output) => {
+var RESOURCE6 = "LiteLLM.PolicyAttachment";
+var LiteLLMPolicyAttachment = Resource7("LiteLLM.PolicyAttachment");
+var isLiteLLMPolicyAttachment = (value5) => Predicate8.hasProperty(value5, "Type") && value5.Type === "LiteLLM.PolicyAttachment";
+var locate5 = (rows, props, output) => {
   if (output !== undefined) {
-    return Effect22.succeed(rows.find((row) => row.attachmentId === output.attachmentId));
+    return Effect24.succeed(rows.find((row) => row.attachmentId === output.attachmentId));
   }
-  const equal = rows.filter((row) => differing5(row, props).length === 0);
-  return equal.length > 1 ? Effect22.fail(new LitellmRegistryAmbiguousError({
+  const equal = rows.filter((row) => differing6(row, props).length === 0);
+  return equal.length > 1 ? Effect24.fail(new LitellmRegistryAmbiguousError({
     ids: equal.map((row) => row.attachmentId),
     name: props.policyName,
-    resource: RESOURCE4
-  })) : Effect22.succeed(equal[0]);
+    resource: RESOURCE6
+  })) : Effect24.succeed(equal[0]);
 };
 var policyAttachmentHandlers = {
   read: ({
     olds,
     output
-  }) => Effect22.gen(function* () {
+  }) => Effect24.gen(function* () {
     if (output === undefined) {
-      yield* dieIfInvalid(RESOURCE4, String(olds.policyName), firstProblem4(olds));
+      yield* dieIfInvalid(RESOURCE6, String(olds.policyName), firstProblem5(olds));
     }
-    const live = yield* locate4(yield* listAttachments(), olds, output);
+    const live = yield* locate5(yield* listAttachments(), olds, output);
     if (live === undefined)
       return;
-    return output === undefined ? Unowned7(live) : live;
+    return output === undefined ? Unowned8(live) : live;
   }),
   diff: ({
     news,
     output
-  }) => Effect22.gen(function* () {
-    if (!isResolved6(news))
+  }) => Effect24.gen(function* () {
+    if (!isResolved7(news))
       return;
-    yield* failIfInvalid(RESOURCE4, String(news.policyName), firstProblem4(news));
+    yield* failIfInvalid(RESOURCE6, String(news.policyName), firstProblem5(news));
     if (output === undefined)
       return;
-    return differing5(output, news).length === 0 ? { action: "noop" } : { action: "replace", deleteFirst: false };
+    return differing6(output, news).length === 0 ? { action: "noop" } : { action: "replace", deleteFirst: false };
   }),
   reconcile: ({
     news,
     output
-  }) => Effect22.gen(function* () {
-    yield* failIfInvalid(RESOURCE4, String(news.policyName), firstProblem4(news));
-    const before = yield* locate4(yield* listAttachments(), news, output);
-    if (before !== undefined && differing5(before, news).length === 0)
+  }) => Effect24.gen(function* () {
+    yield* failIfInvalid(RESOURCE6, String(news.policyName), firstProblem5(news));
+    const before = yield* locate5(yield* listAttachments(), news, output);
+    if (before !== undefined && differing6(before, news).length === 0)
       return before;
     const created = yield* createAttachment(createBody6(news));
     if (created === undefined) {
-      return yield* Effect22.fail(new LitellmRegistryUnreadableError({
+      return yield* Effect24.fail(new LitellmRegistryUnreadableError({
         reason: "the create answered something that is not an attachment",
-        resource: RESOURCE4
+        resource: RESOURCE6
       }));
     }
     const after = (yield* listAttachments()).find((row) => row.attachmentId === created.attachmentId);
     if (after === undefined) {
-      return yield* Effect22.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.policyName, resource: RESOURCE4 }));
+      return yield* Effect24.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.policyName, resource: RESOURCE6 }));
     }
-    const left = differing5(after, news);
+    const left = differing6(after, news);
     if (left.length > 0) {
-      return yield* Effect22.fail(new LitellmRegistryNotConvergedError({
+      return yield* Effect24.fail(new LitellmRegistryNotConvergedError({
         fields: left,
         name: news.policyName,
-        resource: RESOURCE4
+        resource: RESOURCE6
       }));
     }
     return after;
   }),
   delete: ({ output }) => deleteAttachment(output.attachmentId),
-  list: () => Effect22.succeed([])
+  list: () => Effect24.succeed([])
 };
-var LiteLLMPolicyAttachmentProvider = () => Provider6.effect(LiteLLMPolicyAttachment, Effect22.succeed(LiteLLMPolicyAttachment.Provider.of(policyAttachmentHandlers)));
+var LiteLLMPolicyAttachmentProvider = () => Provider7.effect(LiteLLMPolicyAttachment, Effect24.succeed(LiteLLMPolicyAttachment.Provider.of(policyAttachmentHandlers)));
 // src/litellm/policy.ts
-import { Resource as Resource7 } from "alchemy";
-import { Unowned as Unowned8 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved7 } from "alchemy/Diff";
-import * as Provider7 from "alchemy/Provider";
-import * as Effect24 from "effect/Effect";
-import * as Predicate8 from "effect/Predicate";
+import { Resource as Resource8 } from "alchemy";
+import { Unowned as Unowned9 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved8 } from "alchemy/Diff";
+import * as Provider8 from "alchemy/Provider";
+import * as Effect26 from "effect/Effect";
+import * as Predicate9 from "effect/Predicate";
 
 // src/litellm/policy-form.ts
-var firstProblem5 = (props) => {
+var firstProblem6 = (props) => {
   if (isBlank3(props.policyName) || props.policyName !== props.policyName.trim()) {
     return "`policyName` must be a non-blank name with no leading or trailing space";
   }
@@ -1785,11 +1983,11 @@ var toVersion = (value5) => {
     versionStatus: typeof row["version_status"] === "string" ? row["version_status"] : "production"
   };
 };
-var toAttributes7 = (version) => {
+var toAttributes8 = (version) => {
   const { versionStatus: _status, ...attributes } = version;
   return attributes;
 };
-var differing6 = (live, props) => {
+var differing7 = (live, props) => {
   const fields = [];
   if (props.description !== undefined && live.description !== props.description) {
     fields.push("description");
@@ -1813,8 +2011,8 @@ var createBody7 = (props) => ({
   ...props.inherit === undefined ? {} : { inherit: props.inherit },
   ...props.conditionModel === undefined ? {} : { condition: { model: props.conditionModel } }
 });
-var updateBody5 = (props, live) => {
-  const changed = new Set(differing6(live, props));
+var updateBody6 = (props, live) => {
+  const changed = new Set(differing7(live, props));
   return {
     ...changed.has("description") ? { description: props.description ?? null } : {},
     ...changed.has("inherit") ? { inherit: props.inherit ?? null } : {},
@@ -1826,72 +2024,72 @@ var updateBody5 = (props, live) => {
 
 // src/litellm/policy-operations.ts
 import * as policies2 from "@distilled.cloud/litellm/policy_engine";
-import * as Effect23 from "effect/Effect";
-var RESOURCE5 = "LiteLLM.Policy";
-var unreadable2 = (reason) => new LitellmRegistryUnreadableError({ reason, resource: RESOURCE5 });
-var listPolicyVersions = (policyName) => throughFetch(policies2.listPolicyVersionsPoliciesNamePolicyNameVersionsGet({ policy_name: policyName })).pipe(Effect23.flatMap((response) => {
+import * as Effect25 from "effect/Effect";
+var RESOURCE7 = "LiteLLM.Policy";
+var unreadable2 = (reason) => new LitellmRegistryUnreadableError({ reason, resource: RESOURCE7 });
+var listPolicyVersions = (policyName) => throughFetch(policies2.listPolicyVersionsPoliciesNamePolicyNameVersionsGet({ policy_name: policyName })).pipe(Effect25.flatMap((response) => {
   const versions = asRow(bodyOf(response))?.["versions"];
   if (versions === undefined)
-    return Effect23.succeed([]);
+    return Effect25.succeed([]);
   if (!Array.isArray(versions))
-    return Effect23.fail(unreadable2("versions is not an array"));
+    return Effect25.fail(unreadable2("versions is not an array"));
   const parsed = versions.map(toVersion);
-  return parsed.every((each) => each !== undefined) ? Effect23.succeed(parsed) : Effect23.fail(unreadable2("a version has no id or name"));
+  return parsed.every((each) => each !== undefined) ? Effect25.succeed(parsed) : Effect25.fail(unreadable2("a version has no id or name"));
 }));
-var configPolicyNames = () => throughFetch(policies2.listPoliciesPoliciesListGet({ version_status: "production" })).pipe(Effect23.flatMap((response) => {
+var configPolicyNames = () => throughFetch(policies2.listPoliciesPoliciesListGet({ version_status: "production" })).pipe(Effect25.flatMap((response) => {
   const rows = asRow(bodyOf(response))?.["policies"];
   if (!Array.isArray(rows))
-    return Effect23.fail(unreadable2("policies is not an array"));
-  return Effect23.succeed(rows.flatMap((row) => {
+    return Effect25.fail(unreadable2("policies is not an array"));
+  return Effect25.succeed(rows.flatMap((row) => {
     const each = asRow(row);
     return each?.["definition_location"] === "config" && typeof each["policy_name"] === "string" ? [each["policy_name"]] : [];
   }));
 }));
-var createPolicy = (body) => throughFetch(policies2.createPolicyPoliciesPost(body)).pipe(Effect23.asVoid);
-var createDraft = (policyName) => throughFetch(policies2.createPolicyVersionPoliciesNamePolicyNameVersionsPost({ policy_name: policyName })).pipe(Effect23.flatMap((response) => {
+var createPolicy = (body) => throughFetch(policies2.createPolicyPoliciesPost(body)).pipe(Effect25.asVoid);
+var createDraft = (policyName) => throughFetch(policies2.createPolicyVersionPoliciesNamePolicyNameVersionsPost({ policy_name: policyName })).pipe(Effect25.flatMap((response) => {
   const draft = toVersion(bodyOf(response));
-  return draft === undefined ? Effect23.fail(unreadable2("the new draft is not a policy")) : Effect23.succeed(draft);
+  return draft === undefined ? Effect25.fail(unreadable2("the new draft is not a policy")) : Effect25.succeed(draft);
 }));
-var editDraft = (policyId, body) => throughFetch(policies2.updatePolicyPoliciesPolicyIdPut({ ...body, policy_id: policyId })).pipe(Effect23.asVoid);
+var editDraft = (policyId, body) => throughFetch(policies2.updatePolicyPoliciesPolicyIdPut({ ...body, policy_id: policyId })).pipe(Effect25.asVoid);
 var setVersionStatus = (policyId, status) => throughFetch(policies2.updatePolicyVersionStatusPoliciesPolicyIdStatusPut({
   policy_id: policyId,
   version_status: status
-})).pipe(Effect23.asVoid);
+})).pipe(Effect25.asVoid);
 var deleteAllVersions = (policyName) => throughFetch(policies2.deleteAllPolicyVersionsPoliciesNamePolicyNameAllVersionsDelete({
   policy_name: policyName
-})).pipe(Effect23.asVoid);
+})).pipe(Effect25.asVoid);
 
 // src/litellm/policy.ts
-var RESOURCE6 = "LiteLLM.Policy";
-var LiteLLMPolicy = Resource7("LiteLLM.Policy", {
+var RESOURCE8 = "LiteLLM.Policy";
+var LiteLLMPolicy = Resource8("LiteLLM.Policy", {
   defaultRemovalPolicy: "retain"
 });
-var isLiteLLMPolicy = (value5) => Predicate8.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Policy";
+var isLiteLLMPolicy = (value5) => Predicate9.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Policy";
 var production = (versions) => versions.find((version) => version.versionStatus === "production");
-var invalid = (name, problem) => Effect24.fail(new LitellmRegistryInvalidError({ name, problem, resource: RESOURCE6 }));
+var invalid = (name, problem) => Effect26.fail(new LitellmRegistryInvalidError({ name, problem, resource: RESOURCE8 }));
 var policyHandlers = {
-  read: ({ olds, output }) => Effect24.gen(function* () {
+  read: ({ olds, output }) => Effect26.gen(function* () {
     if (output === undefined) {
-      yield* dieIfInvalid(RESOURCE6, String(olds.policyName), firstProblem5(olds));
+      yield* dieIfInvalid(RESOURCE8, String(olds.policyName), firstProblem6(olds));
     }
     const live = production(yield* listPolicyVersions(output?.policyName ?? olds.policyName));
     if (live === undefined)
       return;
-    return output === undefined ? Unowned8(toAttributes7(live)) : toAttributes7(live);
+    return output === undefined ? Unowned9(toAttributes8(live)) : toAttributes8(live);
   }),
-  diff: ({ news, output }) => Effect24.gen(function* () {
-    if (!isResolved7(news))
+  diff: ({ news, output }) => Effect26.gen(function* () {
+    if (!isResolved8(news))
       return;
-    yield* failIfInvalid(RESOURCE6, String(news.policyName), firstProblem5(news));
+    yield* failIfInvalid(RESOURCE8, String(news.policyName), firstProblem6(news));
     if (output === undefined)
       return;
     if (news.policyName !== output.policyName) {
       return { action: "replace", deleteFirst: false };
     }
-    return differing6(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+    return differing7(output, news).length === 0 ? { action: "noop" } : { action: "update" };
   }),
-  reconcile: ({ news }) => Effect24.gen(function* () {
-    yield* failIfInvalid(RESOURCE6, String(news.policyName), firstProblem5(news));
+  reconcile: ({ news }) => Effect26.gen(function* () {
+    yield* failIfInvalid(RESOURCE8, String(news.policyName), firstProblem6(news));
     const versions = yield* listPolicyVersions(news.policyName);
     const live = production(versions);
     if (versions.length === 0) {
@@ -1901,38 +2099,38 @@ var policyHandlers = {
       yield* createPolicy(createBody7(news));
     } else if (live === undefined) {
       return yield* invalid(news.policyName, `${versions.length} version(s) exist and none is production, so the policy is inactive; promote one in LiteLLM (or delete its versions) instead of letting this guess`);
-    } else if (differing6(live, news).length > 0) {
+    } else if (differing7(live, news).length > 0) {
       const draft = yield* createDraft(news.policyName);
-      yield* editDraft(draft.policyId, updateBody5(news, live));
+      yield* editDraft(draft.policyId, updateBody6(news, live));
       yield* setVersionStatus(draft.policyId, "published");
       yield* setVersionStatus(draft.policyId, "production");
     }
     const after = production(yield* listPolicyVersions(news.policyName));
     if (after === undefined) {
-      return yield* Effect24.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.policyName, resource: RESOURCE6 }));
+      return yield* Effect26.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.policyName, resource: RESOURCE8 }));
     }
-    const left = differing6(after, news);
+    const left = differing7(after, news);
     if (left.length > 0) {
-      return yield* Effect24.fail(new LitellmRegistryNotConvergedError({
+      return yield* Effect26.fail(new LitellmRegistryNotConvergedError({
         fields: left,
         name: news.policyName,
-        resource: RESOURCE6
+        resource: RESOURCE8
       }));
     }
-    return toAttributes7(after);
+    return toAttributes8(after);
   }),
   delete: ({ output }) => deleteAllVersions(output.policyName),
-  list: () => Effect24.succeed([])
+  list: () => Effect26.succeed([])
 };
-var LiteLLMPolicyProvider = () => Provider7.effect(LiteLLMPolicy, Effect24.succeed(LiteLLMPolicy.Provider.of(policyHandlers)));
+var LiteLLMPolicyProvider = () => Provider8.effect(LiteLLMPolicy, Effect26.succeed(LiteLLMPolicy.Provider.of(policyHandlers)));
 // src/litellm/team.ts
-import { Resource as Resource8 } from "alchemy";
-import { Unowned as Unowned9 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved8 } from "alchemy/Diff";
+import { Resource as Resource9 } from "alchemy";
+import { Unowned as Unowned10 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved9 } from "alchemy/Diff";
 import { createPhysicalName as createPhysicalName4 } from "alchemy/PhysicalName";
-import * as Provider8 from "alchemy/Provider";
-import * as Effect26 from "effect/Effect";
-import * as Predicate9 from "effect/Predicate";
+import * as Provider9 from "alchemy/Provider";
+import * as Effect28 from "effect/Effect";
+import * as Predicate10 from "effect/Predicate";
 
 // src/litellm/team-members.ts
 var toMemberAttributes = (value5) => {
@@ -2047,7 +2245,7 @@ var permissionProblem = (declared) => {
 };
 
 // src/litellm/team-form.ts
-var firstProblem6 = (props) => {
+var firstProblem7 = (props) => {
   if (isBlank3(props.teamAlias) || props.teamAlias !== props.teamAlias.trim()) {
     return "`teamAlias` must be a non-blank name with no leading or trailing space";
   }
@@ -2079,7 +2277,7 @@ var firstProblem6 = (props) => {
   }
   return permissionProblem(props.objectPermission);
 };
-var toAttributes8 = (value5) => {
+var toAttributes9 = (value5) => {
   const row = asRow(asRow(value5)?.["team_info"]);
   if (row === undefined)
     return;
@@ -2112,7 +2310,7 @@ var teamFieldsDiffering = (live, props) => {
   }
   return fields;
 };
-var differing7 = (live, props) => [
+var differing8 = (live, props) => [
   ...teamFieldsDiffering(live, props),
   ...rosterPending(live.members, props.members) ? ["members"] : []
 ];
@@ -2124,7 +2322,7 @@ var createBody8 = (props, teamId) => ({
   ...props.accessGroupIds === undefined ? {} : { access_group_ids: [...props.accessGroupIds] },
   ...props.objectPermission === undefined ? {} : { object_permission: permissionBody(props.objectPermission) }
 });
-var updateBody6 = (props, live) => {
+var updateBody7 = (props, live) => {
   const changed = new Set(teamFieldsDiffering(live, props));
   if (changed.size === 0)
     return;
@@ -2141,74 +2339,74 @@ var updateBody6 = (props, live) => {
 
 // src/litellm/team-operations.ts
 import * as team from "@distilled.cloud/litellm/team_management";
-import * as Effect25 from "effect/Effect";
-var readTeam = (teamId) => throughFetch(team.getTeamInfoTeamInfo({ team_id: teamId })).pipe(Effect25.map((response) => {
-  const row = toAttributes8(bodyOf(response));
+import * as Effect27 from "effect/Effect";
+var readTeam = (teamId) => throughFetch(team.getTeamInfoTeamInfo({ team_id: teamId })).pipe(Effect27.map((response) => {
+  const row = toAttributes9(bodyOf(response));
   return row?.teamId === teamId ? row : undefined;
-}), Effect25.catch((error) => isNotFound(error) ? Effect25.succeed(undefined) : Effect25.fail(error)));
-var createTeam = (body) => throughFetch(team.postNewTeamTeamNew(body)).pipe(Effect25.asVoid);
-var updateTeam = (body) => throughFetch(team.updateTeamTeamUpdatePost(body)).pipe(Effect25.asVoid);
+}), Effect27.catch((error) => isNotFound(error) ? Effect27.succeed(undefined) : Effect27.fail(error)));
+var createTeam = (body) => throughFetch(team.postNewTeamTeamNew(body)).pipe(Effect27.asVoid);
+var updateTeam = (body) => throughFetch(team.updateTeamTeamUpdatePost(body)).pipe(Effect27.asVoid);
 var addMembers = (teamId, members) => throughFetch(team.teamMemberAddTeamMemberAddPost({
   member: members.map((member) => ({ role: member.role ?? "user", user_id: member.userId })),
   team_id: teamId
-})).pipe(Effect25.asVoid);
+})).pipe(Effect27.asVoid);
 var setMemberRole = (teamId, member) => throughFetch(team.teamMemberUpdateTeamMemberUpdatePost({
   role: member.role ?? "user",
   team_id: teamId,
   user_id: member.userId
-})).pipe(Effect25.asVoid);
-var listTeamIds = () => throughFetch(team.listTeamTeamListGet({})).pipe(Effect25.map((response) => {
+})).pipe(Effect27.asVoid);
+var listTeamIds = () => throughFetch(team.listTeamTeamListGet({})).pipe(Effect27.map((response) => {
   const rows = bodyOf(response);
   return Array.isArray(rows) ? rows.flatMap((row) => {
     const id = asRow(row)?.["team_id"];
     return typeof id === "string" ? [id] : [];
   }) : [];
 }));
-var deleteTeam = (teamId) => throughFetch(team.deleteTeamTeamDeletePost({ team_ids: [teamId] })).pipe(Effect25.asVoid, Effect25.catchTag("NotFound", (original) => listTeamIds().pipe(Effect25.flatMap((ids) => ids.includes(teamId) ? Effect25.fail(original) : Effect25.void))));
+var deleteTeam = (teamId) => throughFetch(team.deleteTeamTeamDeletePost({ team_ids: [teamId] })).pipe(Effect27.asVoid, Effect27.catchTag("NotFound", (original) => listTeamIds().pipe(Effect27.flatMap((ids) => ids.includes(teamId) ? Effect27.fail(original) : Effect27.void))));
 
 // src/litellm/team.ts
-var RESOURCE7 = "LiteLLM.Team";
-var LiteLLMTeam = Resource8("LiteLLM.Team", {
+var RESOURCE9 = "LiteLLM.Team";
+var LiteLLMTeam = Resource9("LiteLLM.Team", {
   defaultRemovalPolicy: "retain"
 });
-var isLiteLLMTeam = (value5) => Predicate9.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Team";
-var idOf3 = (id, instanceId, props, output) => output?.teamId !== undefined ? Effect26.succeed(output.teamId) : props.teamId !== undefined ? Effect26.succeed(props.teamId) : createPhysicalName4({ id, instanceId, lowercase: true, maxLength: 64 });
+var isLiteLLMTeam = (value5) => Predicate10.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Team";
+var idOf3 = (id, instanceId, props, output) => output?.teamId !== undefined ? Effect28.succeed(output.teamId) : props.teamId !== undefined ? Effect28.succeed(props.teamId) : createPhysicalName4({ id, instanceId, lowercase: true, maxLength: 64 });
 var teamHandlers = {
-  read: ({ id, instanceId, olds, output }) => Effect26.gen(function* () {
+  read: ({ id, instanceId, olds, output }) => Effect28.gen(function* () {
     if (output === undefined) {
-      yield* dieIfInvalid(RESOURCE7, String(olds.teamAlias), firstProblem6(olds));
+      yield* dieIfInvalid(RESOURCE9, String(olds.teamAlias), firstProblem7(olds));
     }
     const live = yield* readTeam(yield* idOf3(id, instanceId, olds, output));
     if (live === undefined)
       return;
-    return output === undefined ? Unowned9(live) : live;
+    return output === undefined ? Unowned10(live) : live;
   }),
-  diff: ({ news, output }) => Effect26.gen(function* () {
-    if (!isResolved8(news))
+  diff: ({ news, output }) => Effect28.gen(function* () {
+    if (!isResolved9(news))
       return;
-    yield* failIfInvalid(RESOURCE7, String(news.teamAlias), firstProblem6(news));
+    yield* failIfInvalid(RESOURCE9, String(news.teamAlias), firstProblem7(news));
     if (output === undefined)
       return;
     if (news.teamId !== undefined && news.teamId !== output.teamId) {
       return { action: "replace", deleteFirst: false };
     }
-    return differing7(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+    return differing8(output, news).length === 0 ? { action: "noop" } : { action: "update" };
   }),
-  reconcile: ({ id, instanceId, news, output }) => Effect26.gen(function* () {
-    yield* failIfInvalid(RESOURCE7, String(news.teamAlias), firstProblem6(news));
+  reconcile: ({ id, instanceId, news, output }) => Effect28.gen(function* () {
+    yield* failIfInvalid(RESOURCE9, String(news.teamAlias), firstProblem7(news));
     const teamId = yield* idOf3(id, instanceId, news, output);
     const before = yield* readTeam(teamId);
     if (before === undefined)
       yield* createTeam(createBody8(news, teamId));
     else {
-      const body = updateBody6(news, before);
+      const body = updateBody7(news, before);
       if (body !== undefined)
         yield* updateTeam(body);
     }
     if (news.members !== undefined) {
       const live = yield* readTeam(teamId);
       if (live === undefined) {
-        return yield* Effect26.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.teamAlias, resource: RESOURCE7 }));
+        return yield* Effect28.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.teamAlias, resource: RESOURCE9 }));
       }
       const missing = membersToAdd(live.members, news.members);
       if (missing.length > 0)
@@ -2219,29 +2417,29 @@ var teamHandlers = {
     }
     const after = yield* readTeam(teamId);
     if (after === undefined) {
-      return yield* Effect26.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.teamAlias, resource: RESOURCE7 }));
+      return yield* Effect28.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.teamAlias, resource: RESOURCE9 }));
     }
-    const left = differing7(after, news);
+    const left = differing8(after, news);
     if (left.length > 0) {
-      return yield* Effect26.fail(new LitellmRegistryNotConvergedError({
+      return yield* Effect28.fail(new LitellmRegistryNotConvergedError({
         fields: left,
         name: news.teamAlias,
-        resource: RESOURCE7
+        resource: RESOURCE9
       }));
     }
     return after;
   }),
   delete: ({ output }) => deleteTeam(output.teamId),
-  list: () => Effect26.succeed([])
+  list: () => Effect28.succeed([])
 };
-var LiteLLMTeamProvider = () => Provider8.effect(LiteLLMTeam, Effect26.succeed(LiteLLMTeam.Provider.of(teamHandlers)));
+var LiteLLMTeamProvider = () => Provider9.effect(LiteLLMTeam, Effect28.succeed(LiteLLMTeam.Provider.of(teamHandlers)));
 // src/litellm/tool-policy.ts
-import { Resource as Resource9 } from "alchemy";
-import { Unowned as Unowned10 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved9 } from "alchemy/Diff";
-import * as Provider9 from "alchemy/Provider";
-import * as Effect28 from "effect/Effect";
-import * as Predicate10 from "effect/Predicate";
+import { Resource as Resource10 } from "alchemy";
+import { Unowned as Unowned11 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved10 } from "alchemy/Diff";
+import * as Provider10 from "alchemy/Provider";
+import * as Effect30 from "effect/Effect";
+import * as Predicate11 from "effect/Predicate";
 
 // src/litellm/tool-policy-types.ts
 var DEFAULT_TOOL_POLICY = "untrusted";
@@ -2250,7 +2448,7 @@ var OUTPUT_POLICIES = ["untrusted", "trusted"];
 
 // src/litellm/tool-policy-form.ts
 var shadowed = (name) => name === "list" || name === "spend" || name === "policy/options" || ["/detail", "/logs"].some((suffix) => name.endsWith(suffix));
-var firstProblem7 = (props) => {
+var firstProblem8 = (props) => {
   if (isBlank3(props.toolName) || props.toolName !== props.toolName.trim()) {
     return "`toolName` must be a non-blank name with no leading or trailing space";
   }
@@ -2268,7 +2466,7 @@ var firstProblem7 = (props) => {
   }
   return;
 };
-var toAttributes9 = (value5) => {
+var toAttributes10 = (value5) => {
   const row = asRow(value5);
   if (row === undefined)
     return;
@@ -2284,7 +2482,7 @@ var toAttributes9 = (value5) => {
     toolName
   };
 };
-var differing8 = (live, props) => {
+var differing9 = (live, props) => {
   const fields = [];
   if (props.inputPolicy !== undefined && live.inputPolicy !== props.inputPolicy) {
     fields.push("input_policy");
@@ -2294,8 +2492,8 @@ var differing8 = (live, props) => {
   }
   return fields;
 };
-var updateBody7 = (props, live) => {
-  const changed = live === undefined ? undefined : new Set(differing8(live, props));
+var updateBody8 = (props, live) => {
+  const changed = live === undefined ? undefined : new Set(differing9(live, props));
   return {
     tool_name: props.toolName,
     ...props.inputPolicy !== undefined && (changed === undefined || changed.has("input_policy")) ? { input_policy: props.inputPolicy } : {},
@@ -2305,19 +2503,19 @@ var updateBody7 = (props, live) => {
 
 // src/litellm/tool-policy-operations.ts
 import * as tools from "@distilled.cloud/litellm/tools";
-import * as Effect27 from "effect/Effect";
-var readTool = (toolName) => throughFetch(tools.getToolV1ToolToolNameGet({ tool_name: toolName })).pipe(Effect27.map((response) => {
-  const row = toAttributes9(bodyOf(response));
+import * as Effect29 from "effect/Effect";
+var readTool = (toolName) => throughFetch(tools.getToolV1ToolToolNameGet({ tool_name: toolName })).pipe(Effect29.map((response) => {
+  const row = toAttributes10(bodyOf(response));
   return row?.toolName === toolName ? row : undefined;
-}), Effect27.catch((error) => isNotFound(error) ? Effect27.succeed(undefined) : Effect27.fail(error)));
-var writeToolPolicy = (body) => throughFetch(tools.updateToolPolicyV1ToolPolicyPost(body)).pipe(Effect27.asVoid);
-var resetToolPolicy = (props) => readTool(props.toolName).pipe(Effect27.flatMap((live) => {
+}), Effect29.catch((error) => isNotFound(error) ? Effect29.succeed(undefined) : Effect29.fail(error)));
+var writeToolPolicy = (body) => throughFetch(tools.updateToolPolicyV1ToolPolicyPost(body)).pipe(Effect29.asVoid);
+var resetToolPolicy = (props) => readTool(props.toolName).pipe(Effect29.flatMap((live) => {
   if (live === undefined)
-    return Effect27.void;
+    return Effect29.void;
   const inputStale = props.inputPolicy !== undefined && live.inputPolicy !== DEFAULT_TOOL_POLICY;
   const outputStale = props.outputPolicy !== undefined && live.outputPolicy !== DEFAULT_TOOL_POLICY;
   if (!inputStale && !outputStale)
-    return Effect27.void;
+    return Effect29.void;
   return writeToolPolicy({
     tool_name: props.toolName,
     ...inputStale ? { input_policy: DEFAULT_TOOL_POLICY } : {},
@@ -2326,66 +2524,66 @@ var resetToolPolicy = (props) => readTool(props.toolName).pipe(Effect27.flatMap(
 }));
 
 // src/litellm/tool-policy.ts
-var RESOURCE8 = "LiteLLM.ToolPolicy";
-var LiteLLMToolPolicy = Resource9("LiteLLM.ToolPolicy", {
+var RESOURCE10 = "LiteLLM.ToolPolicy";
+var LiteLLMToolPolicy = Resource10("LiteLLM.ToolPolicy", {
   defaultRemovalPolicy: "retain"
 });
-var isLiteLLMToolPolicy = (value5) => Predicate10.hasProperty(value5, "Type") && value5.Type === "LiteLLM.ToolPolicy";
+var isLiteLLMToolPolicy = (value5) => Predicate11.hasProperty(value5, "Type") && value5.Type === "LiteLLM.ToolPolicy";
 var toolPolicyHandlers = {
-  read: ({ olds, output }) => Effect28.gen(function* () {
+  read: ({ olds, output }) => Effect30.gen(function* () {
     if (output === undefined) {
-      yield* dieIfInvalid(RESOURCE8, String(olds.toolName), firstProblem7(olds));
+      yield* dieIfInvalid(RESOURCE10, String(olds.toolName), firstProblem8(olds));
     }
     const live = yield* readTool(output?.toolName ?? olds.toolName);
     if (live === undefined)
       return;
-    return output === undefined ? Unowned10(live) : live;
+    return output === undefined ? Unowned11(live) : live;
   }),
   diff: ({
     news,
     output
-  }) => Effect28.gen(function* () {
-    if (!isResolved9(news))
+  }) => Effect30.gen(function* () {
+    if (!isResolved10(news))
       return;
-    yield* failIfInvalid(RESOURCE8, String(news.toolName), firstProblem7(news));
+    yield* failIfInvalid(RESOURCE10, String(news.toolName), firstProblem8(news));
     if (output === undefined)
       return;
     if (news.toolName !== output.toolName) {
       return { action: "replace", deleteFirst: false };
     }
-    return differing8(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+    return differing9(output, news).length === 0 ? { action: "noop" } : { action: "update" };
   }),
-  reconcile: ({ news }) => Effect28.gen(function* () {
-    yield* failIfInvalid(RESOURCE8, String(news.toolName), firstProblem7(news));
+  reconcile: ({ news }) => Effect30.gen(function* () {
+    yield* failIfInvalid(RESOURCE10, String(news.toolName), firstProblem8(news));
     const before = yield* readTool(news.toolName);
-    if (before === undefined || differing8(before, news).length > 0) {
-      yield* writeToolPolicy(updateBody7(news, before));
+    if (before === undefined || differing9(before, news).length > 0) {
+      yield* writeToolPolicy(updateBody8(news, before));
     }
     const after = yield* readTool(news.toolName);
     if (after === undefined) {
-      return yield* Effect28.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.toolName, resource: RESOURCE8 }));
+      return yield* Effect30.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.toolName, resource: RESOURCE10 }));
     }
-    const left = differing8(after, news);
+    const left = differing9(after, news);
     if (left.length > 0) {
-      return yield* Effect28.fail(new LitellmRegistryNotConvergedError({
+      return yield* Effect30.fail(new LitellmRegistryNotConvergedError({
         fields: left,
         name: news.toolName,
-        resource: RESOURCE8
+        resource: RESOURCE10
       }));
     }
     return after;
   }),
   delete: ({ olds }) => resetToolPolicy(olds),
-  list: () => Effect28.succeed([])
+  list: () => Effect30.succeed([])
 };
-var LiteLLMToolPolicyProvider = () => Provider9.effect(LiteLLMToolPolicy, Effect28.succeed(LiteLLMToolPolicy.Provider.of(toolPolicyHandlers)));
+var LiteLLMToolPolicyProvider = () => Provider10.effect(LiteLLMToolPolicy, Effect30.succeed(LiteLLMToolPolicy.Provider.of(toolPolicyHandlers)));
 // src/litellm/toolset.ts
-import { Resource as Resource10 } from "alchemy";
-import { Unowned as Unowned11 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved10 } from "alchemy/Diff";
-import * as Provider10 from "alchemy/Provider";
-import * as Effect30 from "effect/Effect";
-import * as Predicate11 from "effect/Predicate";
+import { Resource as Resource11 } from "alchemy";
+import { Unowned as Unowned12 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved11 } from "alchemy/Diff";
+import * as Provider11 from "alchemy/Provider";
+import * as Effect32 from "effect/Effect";
+import * as Predicate12 from "effect/Predicate";
 
 // src/litellm/toolset-form.ts
 var pairKey = (tool) => JSON.stringify([tool.serverId, tool.toolName]);
@@ -2395,7 +2593,7 @@ var sameTools = (left, right) => {
   const b = canonicalTools(right).map(pairKey);
   return a.length === b.length && a.every((each, index) => each === b[index]);
 };
-var firstProblem8 = (props) => {
+var firstProblem9 = (props) => {
   if (isBlank3(props.toolsetName) || props.toolsetName !== props.toolsetName.trim()) {
     return "`toolsetName` must be a non-blank name with no leading or trailing space";
   }
@@ -2416,7 +2614,7 @@ var firstProblem8 = (props) => {
     return `\`tools\` lists ${twice} twice`;
   return;
 };
-var toAttributes10 = (value5) => {
+var toAttributes11 = (value5) => {
   const row = asRow(value5);
   if (row === undefined)
     return;
@@ -2438,7 +2636,7 @@ var toAttributes10 = (value5) => {
     tools: canonicalTools(tools2)
   };
 };
-var differing9 = (live, props) => {
+var differing10 = (live, props) => {
   const fields = [];
   if (live.toolsetName !== props.toolsetName)
     fields.push("toolset_name");
@@ -2455,8 +2653,8 @@ var createBody9 = (props) => ({
   tools: wireTools(props.tools),
   ...props.description === undefined ? {} : { description: props.description }
 });
-var updateBody8 = (props, live) => {
-  const changed = new Set(differing9(live, props));
+var updateBody9 = (props, live) => {
+  const changed = new Set(differing10(live, props));
   return {
     toolset_id: live.toolsetId,
     ...changed.has("toolset_name") ? { toolset_name: props.toolsetName } : {},
@@ -2467,108 +2665,108 @@ var updateBody8 = (props, live) => {
 
 // src/litellm/toolset-operations.ts
 import * as mcp2 from "@distilled.cloud/litellm/mcp_management";
-import * as Effect29 from "effect/Effect";
-var RESOURCE9 = "LiteLLM.Toolset";
-var listToolsets = () => throughFetch(mcp2.fetchMcpToolsetsV1McpToolsetGet({})).pipe(Effect29.flatMap((response) => {
+import * as Effect31 from "effect/Effect";
+var RESOURCE11 = "LiteLLM.Toolset";
+var listToolsets = () => throughFetch(mcp2.fetchMcpToolsetsV1McpToolsetGet({})).pipe(Effect31.flatMap((response) => {
   const rows = bodyOf(response);
   if (!Array.isArray(rows)) {
-    return Effect29.fail(new LitellmRegistryUnreadableError({ reason: "not an array", resource: RESOURCE9 }));
+    return Effect31.fail(new LitellmRegistryUnreadableError({ reason: "not an array", resource: RESOURCE11 }));
   }
-  const parsed = rows.map(toAttributes10);
-  return parsed.every((row) => row !== undefined) ? Effect29.succeed(parsed) : Effect29.fail(new LitellmRegistryUnreadableError({
+  const parsed = rows.map(toAttributes11);
+  return parsed.every((row) => row !== undefined) ? Effect31.succeed(parsed) : Effect31.fail(new LitellmRegistryUnreadableError({
     reason: "a row has no id or name",
-    resource: RESOURCE9
+    resource: RESOURCE11
   }));
 }));
-var readToolset = (toolsetId) => throughFetch(mcp2.fetchMcpToolsetV1McpToolsetToolsetIdGet({ toolset_id: toolsetId })).pipe(Effect29.map((response) => {
-  const row = toAttributes10(bodyOf(response));
+var readToolset = (toolsetId) => throughFetch(mcp2.fetchMcpToolsetV1McpToolsetToolsetIdGet({ toolset_id: toolsetId })).pipe(Effect31.map((response) => {
+  const row = toAttributes11(bodyOf(response));
   return row?.toolsetId === toolsetId ? row : undefined;
-}), Effect29.catch((error) => isNotFound(error) ? Effect29.succeed(undefined) : Effect29.fail(error)));
-var createToolset = (body) => throughFetch(mcp2.addMcpToolsetV1McpToolsetPost(body)).pipe(Effect29.map((response) => toAttributes10(bodyOf(response))));
-var updateToolset = (body) => throughFetch(mcp2.editMcpToolsetV1McpToolsetPut(body)).pipe(Effect29.asVoid);
-var deleteToolset = (toolsetId) => throughFetch(mcp2.removeMcpToolsetV1McpToolsetToolsetIdDelete({ toolset_id: toolsetId })).pipe(Effect29.asVoid, Effect29.catch((original) => readToolset(toolsetId).pipe(Effect29.catch(() => Effect29.fail(original)), Effect29.flatMap((row) => row === undefined ? Effect29.void : Effect29.fail(original)))));
+}), Effect31.catch((error) => isNotFound(error) ? Effect31.succeed(undefined) : Effect31.fail(error)));
+var createToolset = (body) => throughFetch(mcp2.addMcpToolsetV1McpToolsetPost(body)).pipe(Effect31.map((response) => toAttributes11(bodyOf(response))));
+var updateToolset = (body) => throughFetch(mcp2.editMcpToolsetV1McpToolsetPut(body)).pipe(Effect31.asVoid);
+var deleteToolset = (toolsetId) => throughFetch(mcp2.removeMcpToolsetV1McpToolsetToolsetIdDelete({ toolset_id: toolsetId })).pipe(Effect31.asVoid, Effect31.catch((original) => readToolset(toolsetId).pipe(Effect31.catch(() => Effect31.fail(original)), Effect31.flatMap((row) => row === undefined ? Effect31.void : Effect31.fail(original)))));
 
 // src/litellm/toolset.ts
-var RESOURCE10 = "LiteLLM.Toolset";
-var LiteLLMToolset = Resource10("LiteLLM.Toolset", {
+var RESOURCE12 = "LiteLLM.Toolset";
+var LiteLLMToolset = Resource11("LiteLLM.Toolset", {
   defaultRemovalPolicy: "retain"
 });
-var isLiteLLMToolset = (value5) => Predicate11.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Toolset";
-var locate5 = (props, output) => Effect30.gen(function* () {
+var isLiteLLMToolset = (value5) => Predicate12.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Toolset";
+var locate6 = (props, output) => Effect32.gen(function* () {
   if (output !== undefined)
     return yield* readToolset(output.toolsetId);
   const named = (yield* listToolsets()).filter((row) => row.toolsetName === props.toolsetName);
   if (named.length > 1) {
-    return yield* Effect30.fail(new LitellmRegistryAmbiguousError({
+    return yield* Effect32.fail(new LitellmRegistryAmbiguousError({
       ids: named.map((row) => row.toolsetId),
       name: props.toolsetName,
-      resource: RESOURCE10
+      resource: RESOURCE12
     }));
   }
   return named[0];
 });
 var toolsetHandlers = {
-  read: ({ olds, output }) => Effect30.gen(function* () {
+  read: ({ olds, output }) => Effect32.gen(function* () {
     if (output === undefined) {
-      yield* dieIfInvalid(RESOURCE10, String(olds.toolsetName), firstProblem8(olds));
+      yield* dieIfInvalid(RESOURCE12, String(olds.toolsetName), firstProblem9(olds));
     }
-    const live = yield* locate5(olds, output);
+    const live = yield* locate6(olds, output);
     if (live === undefined)
       return;
-    return output === undefined ? Unowned11(live) : live;
+    return output === undefined ? Unowned12(live) : live;
   }),
-  diff: ({ news, output }) => Effect30.gen(function* () {
-    if (!isResolved10(news))
+  diff: ({ news, output }) => Effect32.gen(function* () {
+    if (!isResolved11(news))
       return;
-    yield* failIfInvalid(RESOURCE10, String(news.toolsetName), firstProblem8(news));
+    yield* failIfInvalid(RESOURCE12, String(news.toolsetName), firstProblem9(news));
     if (output === undefined)
       return;
-    return differing9(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+    return differing10(output, news).length === 0 ? { action: "noop" } : { action: "update" };
   }),
-  reconcile: ({ news, output }) => Effect30.gen(function* () {
-    yield* failIfInvalid(RESOURCE10, String(news.toolsetName), firstProblem8(news));
-    const before = yield* locate5(news, output);
+  reconcile: ({ news, output }) => Effect32.gen(function* () {
+    yield* failIfInvalid(RESOURCE12, String(news.toolsetName), firstProblem9(news));
+    const before = yield* locate6(news, output);
     let toolsetId;
     if (before === undefined) {
       const created = yield* createToolset(createBody9(news));
       if (created === undefined) {
-        return yield* Effect30.fail(new LitellmRegistryUnreadableError({
+        return yield* Effect32.fail(new LitellmRegistryUnreadableError({
           reason: "the create answered something that is not a toolset",
-          resource: RESOURCE10
+          resource: RESOURCE12
         }));
       }
       toolsetId = created.toolsetId;
     } else {
       toolsetId = before.toolsetId;
-      if (differing9(before, news).length > 0)
-        yield* updateToolset(updateBody8(news, before));
+      if (differing10(before, news).length > 0)
+        yield* updateToolset(updateBody9(news, before));
     }
     const after = yield* readToolset(toolsetId);
     if (after === undefined) {
-      return yield* Effect30.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.toolsetName, resource: RESOURCE10 }));
+      return yield* Effect32.fail(new LitellmRegistryAbsentAfterWriteError({ name: news.toolsetName, resource: RESOURCE12 }));
     }
-    const left = differing9(after, news);
+    const left = differing10(after, news);
     if (left.length > 0) {
-      return yield* Effect30.fail(new LitellmRegistryNotConvergedError({
+      return yield* Effect32.fail(new LitellmRegistryNotConvergedError({
         fields: left,
         name: news.toolsetName,
-        resource: RESOURCE10
+        resource: RESOURCE12
       }));
     }
     return after;
   }),
   delete: ({ output }) => deleteToolset(output.toolsetId),
-  list: () => Effect30.succeed([])
+  list: () => Effect32.succeed([])
 };
-var LiteLLMToolsetProvider = () => Provider10.effect(LiteLLMToolset, Effect30.succeed(LiteLLMToolset.Provider.of(toolsetHandlers)));
+var LiteLLMToolsetProvider = () => Provider11.effect(LiteLLMToolset, Effect32.succeed(LiteLLMToolset.Provider.of(toolsetHandlers)));
 // src/litellm/model.ts
-import { Resource as Resource11 } from "alchemy";
-import { Unowned as Unowned13 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved11 } from "alchemy/Diff";
+import { Resource as Resource12 } from "alchemy";
+import { Unowned as Unowned14 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved12 } from "alchemy/Diff";
 import { createPhysicalName as createPhysicalName6 } from "alchemy/PhysicalName";
-import * as Provider11 from "alchemy/Provider";
-import * as Effect36 from "effect/Effect";
-import * as Predicate12 from "effect/Predicate";
+import * as Provider12 from "alchemy/Provider";
+import * as Effect38 from "effect/Effect";
+import * as Predicate13 from "effect/Predicate";
 
 // src/litellm/model-errors.ts
 import * as Data6 from "effect/Data";
@@ -2623,14 +2821,14 @@ class LitellmModelConfigFileRowError extends Data6.TaggedError("LitellmModelConf
 }
 
 // src/litellm/model-claim.ts
-import * as Effect33 from "effect/Effect";
+import * as Effect35 from "effect/Effect";
 
 // src/ownership/adopting.ts
-import * as Effect32 from "effect/Effect";
+import * as Effect34 from "effect/Effect";
 
 // src/ownership/probe.ts
-import { Unowned as Unowned12 } from "alchemy/AdoptPolicy";
-import * as Effect31 from "effect/Effect";
+import { Unowned as Unowned13 } from "alchemy/AdoptPolicy";
+import * as Effect33 from "effect/Effect";
 import * as Option5 from "effect/Option";
 var inApplyResource = (span) => {
   let at = span;
@@ -2645,32 +2843,32 @@ var isCreatesRead = (span) => {
   const current = Option5.getOrUndefined(span);
   return current?.name === "provider.read" && inApplyResource(current);
 };
-var readsAtApply = Effect31.map(Effect31.option(Effect31.currentSpan), isCreatesRead);
-var provenOurs = (ask, settled2) => Effect31.gen(function* () {
+var readsAtApply = Effect33.map(Effect33.option(Effect33.currentSpan), isCreatesRead);
+var provenOurs = (ask, settled2) => Effect33.gen(function* () {
   if (yield* readsAtApply)
     return yield* resumes(ask.instanceId);
   const recorded = yield* recordedInstance(ask.fqn, ask.instanceId);
   if (recorded === "absent")
     return false;
   if (recorded === "partial") {
-    yield* Effect31.logWarning(`${ask.fqn}: the interrupted create's state row lacks part of the declaration (a prop ` + "was still an Output when it was written), so the live object is not proven ours");
+    yield* Effect33.logWarning(`${ask.fqn}: the interrupted create's state row lacks part of the declaration (a prop ` + "was still an Output when it was written), so the live object is not proven ours");
     return false;
   }
-  const unproven = (reason) => Effect31.as(Effect31.logWarning(`${ask.fqn}: the interrupted create's object could not be compared with its props ` + `(${reason instanceof Error ? reason.message : String(reason)}), so it is not treated as ours`), false);
-  return yield* settled2.pipe(Effect31.catch(unproven), Effect31.catchDefect(unproven));
+  const unproven = (reason) => Effect33.as(Effect33.logWarning(`${ask.fqn}: the interrupted create's object could not be compared with its props ` + `(${reason instanceof Error ? reason.message : String(reason)}), so it is not treated as ours`), false);
+  return yield* settled2.pipe(Effect33.catch(unproven), Effect33.catchDefect(unproven));
 });
-var ownedRead = (ask, found, settled2) => Effect31.gen(function* () {
+var ownedRead = (ask, found, settled2) => Effect33.gen(function* () {
   if (found === undefined || ask.output !== undefined)
     return found;
   if (yield* provenOurs(ask, settled2))
     return found;
   if (yield* readsAtApply)
     yield* forgetRefusedCreate(ask.fqn, ask.instanceId);
-  return Unowned12(found);
+  return Unowned13(found);
 });
 
 // src/ownership/adopting.ts
-var adopting = (owner, settled2) => Effect32.gen(function* () {
+var adopting = (owner, settled2) => Effect34.gen(function* () {
   if (owner.output === undefined)
     return false;
   const generation = yield* recordedGeneration(owner.fqn, owner.instanceId);
@@ -2682,10 +2880,10 @@ var adopting = (owner, settled2) => Effect32.gen(function* () {
 });
 
 // src/litellm/model-claim.ts
-var claimStatelessRow = (args) => Effect33.gen(function* () {
+var claimStatelessRow = (args) => Effect35.gen(function* () {
   const older = yield* olderGenerationIds(args.fqn, args.instanceId);
   if (older.includes(args.beforeId)) {
-    return yield* Effect33.fail(new LitellmModelPriorGenerationError({
+    return yield* Effect35.fail(new LitellmModelPriorGenerationError({
       fqn: args.fqn,
       id: args.beforeId,
       modelName: args.news.modelName
@@ -2694,12 +2892,12 @@ var claimStatelessRow = (args) => Effect33.gen(function* () {
   const unpinned = args.news.id === undefined;
   const ours = unpinned && args.beforeId === args.wanted;
   const owner = { fqn: args.fqn, instanceId: args.instanceId, output: args.output };
-  const isAdoption = yield* adopting(owner, () => Effect33.succeed(false));
+  const isAdoption = yield* adopting(owner, () => Effect35.succeed(false));
   const creating = yield* isCreate(args.fqn, args.instanceId);
   const mayAdopt = unpinned ? creating && (yield* adoptEnabled(args.fqn)) : yield* adoptsAtApply(owner);
   if (!ours && !isAdoption && !mayAdopt) {
     const replace = unpinned ? !creating : !creating && !(yield* unfinished(args.instanceId));
-    return yield* Effect33.fail(new LitellmModelForeignRowError({
+    return yield* Effect35.fail(new LitellmModelForeignRowError({
       id: args.beforeId,
       modelName: args.news.modelName,
       replace
@@ -2724,7 +2922,7 @@ var sealFromValues = (values) => seal(values);
 var sealState = (props, sealed) => sealMatches(sealed, declaredValues(props)) ? "match" : "stale";
 
 // src/litellm/model-form.ts
-var firstProblem9 = (props) => {
+var firstProblem10 = (props) => {
   if (isBlank4(props.modelName) || props.modelName !== props.modelName.trim()) {
     return "`modelName` must be a non-empty string without leading or trailing whitespace";
   }
@@ -2754,7 +2952,7 @@ var firstProblem9 = (props) => {
 };
 var declaredDigest = (props) => sealFromValues(declaredValues(props));
 var sameSet3 = (live, declared) => new Set(live).size === new Set(declared).size && declared.every((entry) => live.includes(entry));
-var differing10 = (live, props) => {
+var differing11 = (live, props) => {
   const out = [];
   if (live.modelName !== props.modelName)
     out.push("model_name");
@@ -2769,7 +2967,7 @@ var differing10 = (live, props) => {
     out.push("access_groups");
   return out;
 };
-var toAttributes11 = (row) => {
+var toAttributes12 = (row) => {
   const info = row["model_info"] ?? {};
   const params = row["litellm_params"];
   const carriedModel = typeof params === "object" && params !== null ? params["model"] : undefined;
@@ -2830,11 +3028,11 @@ var patchBody2 = (props, live) => {
 
 // src/litellm/model-locate.ts
 import { createPhysicalName as createPhysicalName5 } from "alchemy/PhysicalName";
-import * as Effect35 from "effect/Effect";
+import * as Effect37 from "effect/Effect";
 
 // src/litellm/model-operations.ts
 import * as models from "@distilled.cloud/litellm/model_management";
-import * as Effect34 from "effect/Effect";
+import * as Effect36 from "effect/Effect";
 var hasRowId = (row) => {
   if (typeof row !== "object" || row === null)
     return false;
@@ -2844,49 +3042,49 @@ var hasRowId = (row) => {
 };
 var rowsOf = (response) => {
   const rows = Array.isArray(response) ? response : Array.isArray(response?.data) ? response.data : response?.body;
-  return Array.isArray(rows) && rows.every(hasRowId) ? Effect34.succeed(rows.map(toAttributes11)) : Effect34.fail(new LitellmModelUnreadableError({
+  return Array.isArray(rows) && rows.every(hasRowId) ? Effect36.succeed(rows.map(toAttributes12)) : Effect36.fail(new LitellmModelUnreadableError({
     reason: Array.isArray(rows) ? "a row has no model id" : "not a list of deployments"
   }));
 };
-var listModels = () => throughFetch(models.getModelInfoV1ModelInfo({})).pipe(Effect34.flatMap(rowsOf));
-var readModelRow = (modelId) => throughFetch(models.getModelInfoV1ModelInfo({ litellm_model_id: modelId })).pipe(Effect34.mapError((error) => error), Effect34.catchTag("NotFound", () => Effect34.succeed(undefined)), Effect34.catchTag("BadRequest", (error) => listModels().pipe(Effect34.flatMap((rows) => rows.some((row) => row.id === modelId) ? Effect34.fail(error) : Effect34.succeed(undefined)))), Effect34.flatMap((response) => response === undefined ? Effect34.succeed(undefined) : rowsOf(response).pipe(Effect34.map((rows) => rows.find((row) => row.id === modelId)))));
-var createModel = (body) => throughFetch(models.addNewModelModelNewPost(body)).pipe(Effect34.asVoid);
-var patchModel = (body) => throughFetch(models.patchModelModelModelIdUpdatePatch(body)).pipe(Effect34.asVoid);
-var deleteModel = (modelId) => throughFetch(models.deleteModelModelDeletePost({ id: modelId })).pipe(Effect34.asVoid, Effect34.catchTag("BadRequest", (original) => listModels().pipe(Effect34.flatMap((rows) => rows.some((row) => row.id === modelId) ? Effect34.fail(original) : Effect34.void))));
+var listModels = () => throughFetch(models.getModelInfoV1ModelInfo({})).pipe(Effect36.flatMap(rowsOf));
+var readModelRow = (modelId) => throughFetch(models.getModelInfoV1ModelInfo({ litellm_model_id: modelId })).pipe(Effect36.mapError((error) => error), Effect36.catchTag("NotFound", () => Effect36.succeed(undefined)), Effect36.catchTag("BadRequest", (error) => listModels().pipe(Effect36.flatMap((rows) => rows.some((row) => row.id === modelId) ? Effect36.fail(error) : Effect36.succeed(undefined)))), Effect36.flatMap((response) => response === undefined ? Effect36.succeed(undefined) : rowsOf(response).pipe(Effect36.map((rows) => rows.find((row) => row.id === modelId)))));
+var createModel = (body) => throughFetch(models.addNewModelModelNewPost(body)).pipe(Effect36.asVoid);
+var patchModel = (body) => throughFetch(models.patchModelModelModelIdUpdatePatch(body)).pipe(Effect36.asVoid);
+var deleteModel = (modelId) => throughFetch(models.deleteModelModelDeletePost({ id: modelId })).pipe(Effect36.asVoid, Effect36.catchTag("BadRequest", (original) => listModels().pipe(Effect36.flatMap((rows) => rows.some((row) => row.id === modelId) ? Effect36.fail(original) : Effect36.void))));
 
 // src/litellm/model-locate.ts
-var locate6 = (rows, props, output) => {
+var locate7 = (rows, props, output) => {
   const pinned = output?.id ?? props.id;
   if (pinned !== undefined)
-    return Effect35.succeed(rows.find((row) => row.id === pinned));
+    return Effect37.succeed(rows.find((row) => row.id === pinned));
   const named = rows.filter((row) => row.modelName === props.modelName);
-  return named.length > 1 ? Effect35.fail(new LitellmModelAmbiguousNameError({
+  return named.length > 1 ? Effect37.fail(new LitellmModelAmbiguousNameError({
     ids: named.map((row) => row.id),
     modelName: props.modelName
-  })) : Effect35.succeed(named[0]);
+  })) : Effect37.succeed(named[0]);
 };
-var wantedId2 = (id, instanceId, props, output) => output?.id !== undefined ? Effect35.succeed(output.id) : props.id !== undefined ? Effect35.succeed(props.id) : createPhysicalName5({ id, instanceId, lowercase: true, maxLength: 64 });
-var findLive2 = (id, instanceId, props, output) => Effect35.gen(function* () {
-  const listed = yield* locate6(yield* listModels(), props, output);
+var wantedId2 = (id, instanceId, props, output) => output?.id !== undefined ? Effect37.succeed(output.id) : props.id !== undefined ? Effect37.succeed(props.id) : createPhysicalName5({ id, instanceId, lowercase: true, maxLength: 64 });
+var findLive2 = (id, instanceId, props, output) => Effect37.gen(function* () {
+  const listed = yield* locate7(yield* listModels(), props, output);
   if (listed !== undefined)
     return listed;
   return yield* readModelRow(yield* wantedId2(id, instanceId, props, output));
 });
 
 // src/litellm/model.ts
-var LiteLLMModel = Resource11("LiteLLM.Model", {
+var LiteLLMModel = Resource12("LiteLLM.Model", {
   defaultRemovalPolicy: "retain"
 });
-var isLiteLLMModel = (value5) => Predicate12.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Model";
+var isLiteLLMModel = (value5) => Predicate13.hasProperty(value5, "Type") && value5.Type === "LiteLLM.Model";
 var refuse3 = (props) => {
-  const problem = firstProblem9(props);
-  return problem === undefined ? Effect36.void : Effect36.fail(new LitellmModelInvalidError({ problem, modelName: String(props.modelName) }));
+  const problem = firstProblem10(props);
+  return problem === undefined ? Effect38.void : Effect38.fail(new LitellmModelInvalidError({ problem, modelName: String(props.modelName) }));
 };
 var modelHandlers = {
-  read: ({ id, instanceId, olds, output }) => Effect36.gen(function* () {
-    const problem = output === undefined ? firstProblem9(olds) : undefined;
+  read: ({ id, instanceId, olds, output }) => Effect38.gen(function* () {
+    const problem = output === undefined ? firstProblem10(olds) : undefined;
     if (problem !== undefined) {
-      return yield* Effect36.die(new LitellmModelInvalidError({ problem, modelName: String(olds.modelName) }));
+      return yield* Effect38.die(new LitellmModelInvalidError({ problem, modelName: String(olds.modelName) }));
     }
     const found = yield* findLive2(id, instanceId, olds, output);
     if (found === undefined)
@@ -2901,14 +3099,14 @@ var modelHandlers = {
       if (found.id === physical)
         return found;
     }
-    return output === undefined ? Unowned13(found) : { ...found, paramsSeal: output.paramsSeal };
+    return output === undefined ? Unowned14(found) : { ...found, paramsSeal: output.paramsSeal };
   }),
   diff: ({
     instanceId,
     news,
     output
-  }) => Effect36.gen(function* () {
-    if (!isResolved11(news))
+  }) => Effect38.gen(function* () {
+    if (!isResolved12(news))
       return;
     yield* refuse3(news);
     if (output === undefined)
@@ -2919,9 +3117,9 @@ var modelHandlers = {
     if (news.modelName !== output.modelName && news.id === undefined) {
       return { action: "replace", deleteFirst: false };
     }
-    return differing10(output, news).length === 0 && sealState(news, output.paramsSeal) === "match" ? { action: "noop" } : { action: "update" };
+    return differing11(output, news).length === 0 && sealState(news, output.paramsSeal) === "match" ? { action: "noop" } : { action: "update" };
   }),
-  reconcile: ({ fqn, id, instanceId, news, output }) => Effect36.gen(function* () {
+  reconcile: ({ fqn, id, instanceId, news, output }) => Effect38.gen(function* () {
     yield* refuse3(news);
     const before = yield* findLive2(id, instanceId, news, output);
     let sealed = output?.paramsSeal ?? "";
@@ -2933,7 +3131,7 @@ var modelHandlers = {
       sealed = declaredDigest(news);
     } else {
       if (before.dbModel === false) {
-        return yield* Effect36.fail(new LitellmModelConfigFileRowError({ id: before.id, modelName: news.modelName }));
+        return yield* Effect38.fail(new LitellmModelConfigFileRowError({ id: before.id, modelName: news.modelName }));
       }
       const stateless = output === undefined || output.paramsSeal === "";
       if (stateless) {
@@ -2947,7 +3145,7 @@ var modelHandlers = {
         });
       }
       modelId = before.id;
-      const drifted = differing10(before, news);
+      const drifted = differing11(before, news);
       const sealStale = sealState(news, sealed) === "stale";
       const sealNeedsStamp = sealStale && (sealed !== "" || news.apiKey !== undefined || news.apiBase !== undefined);
       if (drifted.length > 0 || sealNeedsStamp) {
@@ -2958,11 +3156,11 @@ var modelHandlers = {
     }
     const after = (yield* listModels()).find((row) => row.id === modelId) ?? (yield* readModelRow(modelId));
     if (after === undefined) {
-      return yield* Effect36.fail(new LitellmModelAbsentAfterWriteError({ id: modelId, modelName: news.modelName }));
+      return yield* Effect38.fail(new LitellmModelAbsentAfterWriteError({ id: modelId, modelName: news.modelName }));
     }
-    const left = differing10(after, news);
+    const left = differing11(after, news);
     if (left.length > 0) {
-      return yield* Effect36.fail(new LitellmModelNotConvergedError({
+      return yield* Effect38.fail(new LitellmModelNotConvergedError({
         fields: left,
         id: modelId,
         modelName: news.modelName
@@ -2971,16 +3169,16 @@ var modelHandlers = {
     return { ...after, paramsSeal: sealed };
   }),
   delete: ({ output }) => deleteModel(output.id),
-  list: () => Effect36.succeed([])
+  list: () => Effect38.succeed([])
 };
-var LiteLLMModelProvider = () => Provider11.effect(LiteLLMModel, Effect36.succeed(LiteLLMModel.Provider.of(modelHandlers)));
+var LiteLLMModelProvider = () => Provider12.effect(LiteLLMModel, Effect38.succeed(LiteLLMModel.Provider.of(modelHandlers)));
 // src/litellm/key.ts
-import { Resource as Resource12 } from "alchemy";
-import { Unowned as Unowned14 } from "alchemy/AdoptPolicy";
-import { isResolved as isResolved12 } from "alchemy/Diff";
-import * as Provider12 from "alchemy/Provider";
-import * as Effect39 from "effect/Effect";
-import * as Predicate14 from "effect/Predicate";
+import { Resource as Resource13 } from "alchemy";
+import { Unowned as Unowned15 } from "alchemy/AdoptPolicy";
+import { isResolved as isResolved13 } from "alchemy/Diff";
+import * as Provider13 from "alchemy/Provider";
+import * as Effect41 from "effect/Effect";
+import * as Predicate15 from "effect/Predicate";
 
 // src/litellm/key-errors.ts
 import * as Data7 from "effect/Data";
@@ -3071,7 +3269,7 @@ import * as Redacted5 from "effect/Redacted";
 import { deepEqual as deepEqual2 } from "alchemy/Diff";
 var CALLBACK_SLOTS = ["callback_settings", "logging", "secret_manager_settings"];
 var isObject = (value5) => typeof value5 === "object" && value5 !== null && !Array.isArray(value5);
-var callbackSlotsIn = (metadata) => metadata === undefined ? [] : CALLBACK_SLOTS.filter((slot) => Object.hasOwn(metadata, slot));
+var callbackSlotsIn = (metadata2) => metadata2 === undefined ? [] : CALLBACK_SLOTS.filter((slot) => Object.hasOwn(metadata2, slot));
 var splitMetadata = (raw) => {
   if (!isObject(raw))
     return { metadata: {}, withheld: [] };
@@ -3094,7 +3292,7 @@ var sameSet4 = (a, b) => {
   return left.length === right.length && left.every((value6, i) => value6 === right[i]);
 };
 var expiryDiffers = (live, wanted) => live.duration !== wanted || wanted === null !== (live.expires === null);
-var differing11 = (live, props) => {
+var differing12 = (live, props) => {
   const out = [];
   if (props.budgetId !== undefined && live.budgetId !== props.budgetId)
     out.push("budget_id");
@@ -3130,9 +3328,9 @@ var createBody11 = (props, secret) => {
     body.duration = props.duration;
   return body;
 };
-var updateBody9 = (props, live) => {
+var updateBody10 = (props, live) => {
   const body = { key_alias: live.keyAlias };
-  for (const field of differing11(live, props)) {
+  for (const field of differing12(live, props)) {
     if (field === "budget_id")
       body.budget_id = props.budgetId ?? null;
     if (field === "models")
@@ -3150,15 +3348,15 @@ var updateBody9 = (props, live) => {
 };
 var strings = (value6) => Array.isArray(value6) ? value6.filter((item) => typeof item === "string") : [];
 var stringOrNull2 = (value6) => typeof value6 === "string" ? value6 : null;
-var toAttributes12 = (row) => {
-  const { metadata, withheld } = splitMetadata(row["metadata"]);
+var toAttributes13 = (row) => {
+  const { metadata: metadata2, withheld } = splitMetadata(row["metadata"]);
   return {
     allowedRoutes: strings(row["allowed_routes"]),
     budgetId: stringOrNull2(row["budget_id"]),
     duration: null,
     expires: stringOrNull2(row["expires"]),
     keyAlias: String(row["key_alias"]),
-    metadata,
+    metadata: metadata2,
     models: strings(row["models"]),
     teamId: stringOrNull2(row["team_id"]),
     withheld
@@ -3182,12 +3380,12 @@ class LitellmKeyCallbackMetadataLiveError extends Data8.TaggedError("LitellmKeyC
 
 // src/litellm/key-operations.ts
 import * as keys from "@distilled.cloud/litellm/key_management";
-import * as Effect37 from "effect/Effect";
-import * as Predicate13 from "effect/Predicate";
+import * as Effect39 from "effect/Effect";
+import * as Predicate14 from "effect/Predicate";
 import { isHttpClientError as isHttpClientError2 } from "effect/http/HttpClientError";
-var findKey = (keyAlias) => keyAlias.trim() === "" ? Effect37.fail(new LitellmKeyAliasEmptyError) : findKeyByAlias(keyAlias);
-var findKeyByAlias = (keyAlias) => findKeyRowByAlias(keyAlias).pipe(Effect37.map((row) => row === undefined ? undefined : toAttributes12(row)));
-var findKeyRowByAlias = (keyAlias) => throughFetch(keys.listKeysKeyListGet({ key_alias: keyAlias, return_full_object: true })).pipe(Effect37.flatMap((response) => Effect37.gen(function* () {
+var findKey = (keyAlias) => keyAlias.trim() === "" ? Effect39.fail(new LitellmKeyAliasEmptyError) : findKeyByAlias(keyAlias);
+var findKeyByAlias = (keyAlias) => findKeyRowByAlias(keyAlias).pipe(Effect39.map((row) => row === undefined ? undefined : toAttributes13(row)));
+var findKeyRowByAlias = (keyAlias) => throughFetch(keys.listKeysKeyListGet({ key_alias: keyAlias, return_full_object: true })).pipe(Effect39.flatMap((response) => Effect39.gen(function* () {
   const rows = response.keys ?? [];
   if (rows.some((row) => typeof row !== "object" || row === null)) {
     return yield* new LitellmKeyUnreadableError({ keyAlias });
@@ -3198,26 +3396,26 @@ var findKeyRowByAlias = (keyAlias) => throughFetch(keys.listKeysKeyListGet({ key
   }
   return mine[0];
 })));
-var readKeyToken = (keyAlias) => keyAlias.trim() === "" ? Effect37.fail(new LitellmKeyAliasEmptyError) : findKeyRowByAlias(keyAlias).pipe(Effect37.map((row) => row === undefined ? undefined : typeof row["token"] === "string" ? row["token"] : null));
-var carriesRequest2 = (value6) => isHttpClientError2(value6) || Predicate13.hasProperty(value6, "request");
+var readKeyToken = (keyAlias) => keyAlias.trim() === "" ? Effect39.fail(new LitellmKeyAliasEmptyError) : findKeyRowByAlias(keyAlias).pipe(Effect39.map((row) => row === undefined ? undefined : typeof row["token"] === "string" ? row["token"] : null));
+var carriesRequest2 = (value6) => isHttpClientError2(value6) || Predicate14.hasProperty(value6, "request");
 var generateKey = (body) => {
   const keyAlias = body.key_alias ?? "";
-  return throughFetch(keys.generateKeyFnKeyGeneratePost(body)).pipe(Effect37.catchTag("HttpClientError", (error) => Effect37.fail(new LitellmKeyTransportError({ keyAlias, reason: error.reason._tag }))), Effect37.catchDefect((defect) => carriesRequest2(defect) ? Effect37.fail(new LitellmKeyTransportError({
+  return throughFetch(keys.generateKeyFnKeyGeneratePost(body)).pipe(Effect39.catchTag("HttpClientError", (error) => Effect39.fail(new LitellmKeyTransportError({ keyAlias, reason: error.reason._tag }))), Effect39.catchDefect((defect) => carriesRequest2(defect) ? Effect39.fail(new LitellmKeyTransportError({
     keyAlias,
     reason: isHttpClientError2(defect) ? defect.reason._tag : "Defect"
-  })) : Effect37.die(defect)));
+  })) : Effect39.die(defect)));
 };
-var updateKey = (body) => throughFetch(keys.updateKeyFnKeyUpdatePost(body)).pipe(Effect37.asVoid);
-var deleteKey = (keyAlias) => findKey(keyAlias).pipe(Effect37.flatMap((live) => live === undefined ? Effect37.void : throughFetch(keys.deleteKeyFnKeyDeletePost({ key_aliases: [keyAlias] })).pipe(Effect37.asVoid, Effect37.catchTag("KeyNotFound", (original) => findKey(keyAlias).pipe(Effect37.flatMap((still) => still === undefined ? Effect37.void : Effect37.fail(original)))))));
+var updateKey = (body) => throughFetch(keys.updateKeyFnKeyUpdatePost(body)).pipe(Effect39.asVoid);
+var deleteKey = (keyAlias) => findKey(keyAlias).pipe(Effect39.flatMap((live) => live === undefined ? Effect39.void : throughFetch(keys.deleteKeyFnKeyDeletePost({ key_aliases: [keyAlias] })).pipe(Effect39.asVoid, Effect39.catchTag("KeyNotFound", (original) => findKey(keyAlias).pipe(Effect39.flatMap((still) => still === undefined ? Effect39.void : Effect39.fail(original)))))));
 
 // src/litellm/key-secret.ts
 import { createHash } from "node:crypto";
-import * as Effect38 from "effect/Effect";
+import * as Effect40 from "effect/Effect";
 import * as Redacted6 from "effect/Redacted";
 var PREFIX2 = "sk-";
 var MIN_LENGTH = 16;
 var RULE = `a user-defined key must start with '${PREFIX2}', be at least ${MIN_LENGTH} characters and contain no whitespace`;
-var resolveKeyValue = (keyAlias, ref) => Effect38.gen(function* () {
+var resolveKeyValue = (keyAlias, ref) => Effect40.gen(function* () {
   if (ref === undefined)
     return yield* new LitellmKeyValueRequiredError({ keyAlias });
   const variable = ref.fromEnv;
@@ -3231,7 +3429,7 @@ var resolveKeyValue = (keyAlias, ref) => Effect38.gen(function* () {
 });
 var echoes = (returned, sent) => (Redacted6.isRedacted(returned) ? Redacted6.value(returned) : returned) === Redacted6.value(sent);
 var sha256 = (value7) => createHash("sha256").update(value7).digest("hex");
-var verifyKeyValue = (keyAlias, ref, token) => Effect38.gen(function* () {
+var verifyKeyValue = (keyAlias, ref, token) => Effect40.gen(function* () {
   if (ref === undefined)
     return;
   const variable = ref.fromEnv;
@@ -3242,18 +3440,18 @@ var verifyKeyValue = (keyAlias, ref, token) => Effect38.gen(function* () {
     return yield* new LitellmKeyValueMismatchError({ keyAlias, variable });
   }
 });
-var refuseDebugLogging2 = (keyAlias) => (globalThis.process?.env?.["DISTILLED_DEBUG_HTTP"] ?? "") !== "" ? Effect38.fail(new LitellmKeyDebugLoggingError({ keyAlias })) : Effect38.void;
+var refuseDebugLogging2 = (keyAlias) => (globalThis.process?.env?.["DISTILLED_DEBUG_HTTP"] ?? "") !== "" ? Effect40.fail(new LitellmKeyDebugLoggingError({ keyAlias })) : Effect40.void;
 var hasKeyValue = (ref) => ref !== undefined && resolveAll({ key: ref }).values["key"] !== undefined;
 
 // src/litellm/key.ts
-var LiteLLMKey = Resource12("LiteLLM.Key", { defaultRemovalPolicy: "retain" });
-var isLiteLLMKey = (value7) => Predicate14.hasProperty(value7, "Type") && value7.Type === "LiteLLM.Key";
+var LiteLLMKey = Resource13("LiteLLM.Key", { defaultRemovalPolicy: "retain" });
+var isLiteLLMKey = (value7) => Predicate15.hasProperty(value7, "Type") && value7.Type === "LiteLLM.Key";
 var remembering = (live, output) => ({
   ...live,
   duration: output?.duration ?? null
 });
 var remembered = (news, before) => news.duration !== undefined ? news.duration : before?.duration ?? null;
-var refuseMetadata = (news, live) => Effect39.gen(function* () {
+var refuseMetadata = (news, live) => Effect41.gen(function* () {
   const declared = callbackSlotsIn(news.metadata);
   if (declared.length > 0) {
     return yield* new LitellmKeyCallbackMetadataDeclaredError({
@@ -3261,31 +3459,31 @@ var refuseMetadata = (news, live) => Effect39.gen(function* () {
       slots: declared
     });
   }
-  if (live !== undefined && live.withheld.length > 0 && differing11(live, news).includes("metadata")) {
+  if (live !== undefined && live.withheld.length > 0 && differing12(live, news).includes("metadata")) {
     return yield* new LitellmKeyCallbackMetadataLiveError({
       keyAlias: news.keyAlias,
       slots: live.withheld
     });
   }
 });
-var createKey = (news) => Effect39.gen(function* () {
+var createKey = (news) => Effect41.gen(function* () {
   yield* refuseDebugLogging2(news.keyAlias);
   const secret = yield* resolveKeyValue(news.keyAlias, news.key);
   const created = yield* generateKey(createBody11(news, secret));
   if (echoes(created.key, secret))
     return;
-  const removed = yield* deleteKey(news.keyAlias).pipe(Effect39.as(true), Effect39.orElseSucceed(() => false));
+  const removed = yield* deleteKey(news.keyAlias).pipe(Effect41.as(true), Effect41.orElseSucceed(() => false));
   return yield* new LitellmKeyValueNotHonouredError({ keyAlias: news.keyAlias, removed });
 });
 var keyHandlers = {
-  read: ({ olds, output }) => Effect39.gen(function* () {
+  read: ({ olds, output }) => Effect41.gen(function* () {
     const live = yield* findKey(output?.keyAlias ?? olds.keyAlias);
     if (live === undefined)
       return;
-    return output === undefined ? Unowned14(live) : remembering(live, output);
+    return output === undefined ? Unowned15(live) : remembering(live, output);
   }),
-  diff: ({ news, output }) => Effect39.gen(function* () {
-    if (!isResolved12(news))
+  diff: ({ news, output }) => Effect41.gen(function* () {
+    if (!isResolved13(news))
       return;
     yield* refuseMetadata(news, output);
     if (output === undefined)
@@ -3299,14 +3497,14 @@ var keyHandlers = {
         return { action: "update" };
       yield* verifyKeyValue(news.keyAlias, news.key, token);
     }
-    return differing11(output, news).length === 0 ? { action: "noop" } : { action: "update" };
+    return differing12(output, news).length === 0 ? { action: "noop" } : { action: "update" };
   }),
   reconcile: ({
     fqn,
     instanceId,
     news,
     output
-  }) => Effect39.gen(function* () {
+  }) => Effect41.gen(function* () {
     const alias = news.keyAlias;
     yield* refuseMetadata(news, undefined);
     const found = yield* findKey(alias);
@@ -3319,32 +3517,34 @@ var keyHandlers = {
         yield* verifyKeyValue(alias, news.key, (yield* readKeyToken(alias)) ?? null);
       }
       yield* refuseMetadata(news, before);
-      if (differing11(before, news).length > 0)
-        yield* updateKey(updateBody9(news, before));
+      if (differing12(before, news).length > 0)
+        yield* updateKey(updateBody10(news, before));
     }
     const after = yield* findKey(alias);
     if (after === undefined)
       return yield* new LitellmKeyAbsentAfterWriteError({ keyAlias: alias });
     const settled2 = { ...after, duration: remembered(news, before) };
-    const left = differing11(settled2, news);
+    const left = differing12(settled2, news);
     if (left.length > 0) {
       return yield* new LitellmKeyFieldNotAppliedError({ fields: left, keyAlias: alias });
     }
     return settled2;
   }),
   delete: ({ output }) => deleteKey(output.keyAlias),
-  list: () => Effect39.succeed([])
+  list: () => Effect41.succeed([])
 };
-var LiteLLMKeyProvider = () => Provider12.effect(LiteLLMKey, Effect39.succeed(LiteLLMKey.Provider.of(keyHandlers)));
+var LiteLLMKeyProvider = () => Provider13.effect(LiteLLMKey, Effect41.succeed(LiteLLMKey.Provider.of(keyHandlers)));
 // src/litellm/providers.ts
 import { CredentialsFromEnv } from "@distilled.cloud/litellm/Credentials";
 import * as Layer from "effect/Layer";
-var litellmProviders = (creds = CredentialsFromEnv) => Layer.mergeAll(LiteLLMPassThroughEndpointProvider(), LiteLLMBudgetProvider(), LiteLLMCredentialProvider(), LiteLLMMCPServerProvider(), LiteLLMAccessGroupProvider(), LiteLLMToolsetProvider(), LiteLLMToolPolicyProvider(), LiteLLMPolicyProvider(), LiteLLMPolicyAttachmentProvider(), LiteLLMTeamProvider(), LiteLLMKeyProvider(), LiteLLMModelProvider()).pipe(Layer.provideMerge(creds));
+var litellmProviders = (creds = CredentialsFromEnv) => Layer.mergeAll(LiteLLMPassThroughEndpointProvider(), LiteLLMBudgetProvider(), LiteLLMCredentialProvider(), LiteLLMMCPServerProvider(), LiteLLMAccessGroupProvider(), LiteLLMClaudeCodeMarketplacePluginProvider(), LiteLLMToolsetProvider(), LiteLLMToolPolicyProvider(), LiteLLMPolicyProvider(), LiteLLMPolicyAttachmentProvider(), LiteLLMTeamProvider(), LiteLLMKeyProvider(), LiteLLMModelProvider()).pipe(Layer.provideMerge(creds));
 export {
   LiteLLMAccessGroup,
   LiteLLMAccessGroupProvider,
   LiteLLMBudget,
   LiteLLMBudgetProvider,
+  LiteLLMClaudeCodeMarketplacePlugin,
+  LiteLLMClaudeCodeMarketplacePluginProvider,
   LiteLLMCredential,
   LiteLLMCredentialProvider,
   LiteLLMKey,
@@ -3412,6 +3612,7 @@ export {
   LitellmUnaddressableRowError,
   isLiteLLMAccessGroup,
   isLiteLLMBudget,
+  isLiteLLMClaudeCodeMarketplacePlugin,
   isLiteLLMCredential,
   isLiteLLMKey,
   isLiteLLMMCPServer,
@@ -3425,5 +3626,5 @@ export {
   litellmProviders
 };
 
-//# debugId=A355FEB04988E22764756E2164756E21
+//# debugId=7E0878290952A6B164756E2164756E21
 //# sourceMappingURL=index.js.map