openwork-server 0.18.57 → 0.18.59

package/dist/opencode-plugins/openwork-gateway-quota-v2.js

@@ -13591,6 +13591,7 @@ function gatewayUsdToMicroUsd(value) {
 }
 var gatewayUsagePolicyWriteSchema = exports_external.object({
   name: exports_external.string().trim().min(1).max(120),
+  providerId: exports_external.string().min(1).max(64).nullable().optional(),
   hardLimit: exports_external.boolean().default(true),
   allowRequestReset: exports_external.boolean().default(true),
   limits: exports_external.array(exports_external.object({
@@ -13635,6 +13636,7 @@ var gatewayUsageLimitPolicySchema = exports_external.object({
   hardLimit: exports_external.boolean(),
   allowRequestReset: exports_external.boolean(),
   revision: exports_external.number().int(),
+  providerId: exports_external.string().nullable().optional(),
   limits: exports_external.array(exports_external.object({ timeframe: gatewayUsageTimeframeSchema, costLimitMicroUsd: moneySchema })),
   assignments: exports_external.array(exports_external.object({
     id: exports_external.string(),
@@ -13644,6 +13646,31 @@ var gatewayUsageLimitPolicySchema = exports_external.object({
   })),
   archivedAt: exports_external.iso.datetime().nullable().optional()
 });
+var gatewayUsageBucketSchema = exports_external.object({
+  id: exports_external.string(),
+  timeframe: gatewayUsageTimeframeSchema,
+  policyId: exports_external.string(),
+  policyName: exports_external.string(),
+  policyRevision: exports_external.number().int().positive().optional(),
+  provenance: exports_external.array(gatewayUsageProvenanceSchema).optional(),
+  baseAllowanceMicroUsd: moneySchema,
+  extensionMicroUsd: moneySchema,
+  allowanceMicroUsd: moneySchema,
+  usedMicroUsd: moneySchema,
+  remainingMicroUsd: exports_external.number().int().min(-Number.MAX_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER),
+  resetAt: exports_external.iso.datetime(),
+  hardLimit: exports_external.boolean(),
+  allowRequestReset: exports_external.boolean(),
+  canRequestReset: exports_external.boolean(),
+  resetRequestStatus: exports_external.enum(["pending", "approved", "denied", "expired"]).nullable(),
+  providerId: exports_external.string().nullable().optional()
+});
+var gatewayProviderUsageSchema = exports_external.object({
+  providerId: exports_external.string().min(1),
+  providerName: exports_external.string(),
+  state: exports_external.enum(["within_limit", "over_limit", "blocked"]),
+  buckets: exports_external.array(gatewayUsageBucketSchema)
+});
 var gatewayUsageStatusSchema = exports_external.object({
   serverTime: exports_external.iso.datetime(),
   organizationId: exports_external.string(),
@@ -13664,24 +13691,8 @@ var gatewayUsageStatusSchema = exports_external.object({
     lastSettlementRequestId: exports_external.string().nullable().optional(),
     settlementReady: exports_external.boolean().optional()
   }),
-  buckets: exports_external.array(exports_external.object({
-    id: exports_external.string(),
-    timeframe: gatewayUsageTimeframeSchema,
-    policyId: exports_external.string(),
-    policyName: exports_external.string(),
-    policyRevision: exports_external.number().int().positive().optional(),
-    provenance: exports_external.array(gatewayUsageProvenanceSchema).optional(),
-    baseAllowanceMicroUsd: moneySchema,
-    extensionMicroUsd: moneySchema,
-    allowanceMicroUsd: moneySchema,
-    usedMicroUsd: moneySchema,
-    remainingMicroUsd: exports_external.number().int().min(-Number.MAX_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER),
-    resetAt: exports_external.iso.datetime(),
-    hardLimit: exports_external.boolean(),
-    allowRequestReset: exports_external.boolean(),
-    canRequestReset: exports_external.boolean(),
-    resetRequestStatus: exports_external.enum(["pending", "approved", "denied", "expired"]).nullable()
-  }))
+  buckets: exports_external.array(gatewayUsageBucketSchema),
+  providers: exports_external.array(gatewayProviderUsageSchema).optional()
 });
 var gatewayUsageResetRequestSchema = exports_external.object({
   id: exports_external.string(),
@@ -13691,6 +13702,8 @@ var gatewayUsageResetRequestSchema = exports_external.object({
   bucketId: exports_external.string(),
   timeframe: gatewayUsageTimeframeSchema,
   policyName: exports_external.string(),
+  providerId: exports_external.string().nullable().optional(),
+  providerName: exports_external.string().nullable().optional(),
   reason: exports_external.string(),
   status: exports_external.enum(["pending", "approved", "denied", "expired"]),
   createdAt: exports_external.iso.datetime(),
@@ -13787,6 +13800,14 @@ async function isGatewayQuotaResponse(base, url2, response) {
 }
 
 // src/opencode-plugins/openwork-gateway-quota-v2.ts
+async function preventQuotaRetry(event, base) {
+  if (!await isGatewayQuotaResponse(base, new URL(event.request.url), event.response))
+    return;
+  const response = event.response;
+  const headers = new Headers(response.headers);
+  headers.set("x-should-retry", "false");
+  event.response = new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
 var openwork_gateway_quota_v2_default = {
   id: "openwork.gateway-quota",
   setup: async (context) => {
@@ -13797,14 +13818,24 @@ var openwork_gateway_quota_v2_default = {
       if (!base)
         continue;
       registrations.push(await context.session.hook("http.response", async (event) => {
-        if (event.model.providerID !== id || !await isGatewayQuotaResponse(base, new URL(event.request.url), event.response))
-          return;
-        const response = event.response;
-        const headers = new Headers(response.headers);
-        headers.set("x-should-retry", "false");
-        event.response = new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+        if (event.model.providerID === id)
+          await preventQuotaRetry(event, base);
       }, { providerID: id }));
     }
+    if (context.options.liveProviders === true && context.provider) {
+      const provider = context.provider;
+      registrations.push(await context.session.hook("http.response", async (event) => {
+        const id = event.model.providerID;
+        if (!/^ipr_[a-z0-9]+$/.test(id) || Object.hasOwn(providers, id))
+          return;
+        const current = await provider.get({ providerID: id }).catch(() => {
+          return;
+        });
+        const base = gatewayBase(id, current?.settings?.baseURL);
+        if (base)
+          await preventQuotaRetry(event, base);
+      }));
+    }
     return async () => {
       for (const registration of registrations)
         await registration.dispose();

package/dist/opencode-plugins/openwork-gateway-quota.js

@@ -13905,6 +13905,7 @@ function gatewayUsdToMicroUsd(value) {
 }
 var gatewayUsagePolicyWriteSchema = exports_external.object({
   name: exports_external.string().trim().min(1).max(120),
+  providerId: exports_external.string().min(1).max(64).nullable().optional(),
   hardLimit: exports_external.boolean().default(true),
   allowRequestReset: exports_external.boolean().default(true),
   limits: exports_external.array(exports_external.object({
@@ -13949,6 +13950,7 @@ var gatewayUsageLimitPolicySchema = exports_external.object({
   hardLimit: exports_external.boolean(),
   allowRequestReset: exports_external.boolean(),
   revision: exports_external.number().int(),
+  providerId: exports_external.string().nullable().optional(),
   limits: exports_external.array(exports_external.object({ timeframe: gatewayUsageTimeframeSchema, costLimitMicroUsd: moneySchema })),
   assignments: exports_external.array(exports_external.object({
     id: exports_external.string(),
@@ -13958,6 +13960,31 @@ var gatewayUsageLimitPolicySchema = exports_external.object({
   })),
   archivedAt: exports_external.iso.datetime().nullable().optional()
 });
+var gatewayUsageBucketSchema = exports_external.object({
+  id: exports_external.string(),
+  timeframe: gatewayUsageTimeframeSchema,
+  policyId: exports_external.string(),
+  policyName: exports_external.string(),
+  policyRevision: exports_external.number().int().positive().optional(),
+  provenance: exports_external.array(gatewayUsageProvenanceSchema).optional(),
+  baseAllowanceMicroUsd: moneySchema,
+  extensionMicroUsd: moneySchema,
+  allowanceMicroUsd: moneySchema,
+  usedMicroUsd: moneySchema,
+  remainingMicroUsd: exports_external.number().int().min(-Number.MAX_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER),
+  resetAt: exports_external.iso.datetime(),
+  hardLimit: exports_external.boolean(),
+  allowRequestReset: exports_external.boolean(),
+  canRequestReset: exports_external.boolean(),
+  resetRequestStatus: exports_external.enum(["pending", "approved", "denied", "expired"]).nullable(),
+  providerId: exports_external.string().nullable().optional()
+});
+var gatewayProviderUsageSchema = exports_external.object({
+  providerId: exports_external.string().min(1),
+  providerName: exports_external.string(),
+  state: exports_external.enum(["within_limit", "over_limit", "blocked"]),
+  buckets: exports_external.array(gatewayUsageBucketSchema)
+});
 var gatewayUsageStatusSchema = exports_external.object({
   serverTime: exports_external.iso.datetime(),
   organizationId: exports_external.string(),
@@ -13978,24 +14005,8 @@ var gatewayUsageStatusSchema = exports_external.object({
     lastSettlementRequestId: exports_external.string().nullable().optional(),
     settlementReady: exports_external.boolean().optional()
   }),
-  buckets: exports_external.array(exports_external.object({
-    id: exports_external.string(),
-    timeframe: gatewayUsageTimeframeSchema,
-    policyId: exports_external.string(),
-    policyName: exports_external.string(),
-    policyRevision: exports_external.number().int().positive().optional(),
-    provenance: exports_external.array(gatewayUsageProvenanceSchema).optional(),
-    baseAllowanceMicroUsd: moneySchema,
-    extensionMicroUsd: moneySchema,
-    allowanceMicroUsd: moneySchema,
-    usedMicroUsd: moneySchema,
-    remainingMicroUsd: exports_external.number().int().min(-Number.MAX_SAFE_INTEGER).max(Number.MAX_SAFE_INTEGER),
-    resetAt: exports_external.iso.datetime(),
-    hardLimit: exports_external.boolean(),
-    allowRequestReset: exports_external.boolean(),
-    canRequestReset: exports_external.boolean(),
-    resetRequestStatus: exports_external.enum(["pending", "approved", "denied", "expired"]).nullable()
-  }))
+  buckets: exports_external.array(gatewayUsageBucketSchema),
+  providers: exports_external.array(gatewayProviderUsageSchema).optional()
 });
 var gatewayUsageResetRequestSchema = exports_external.object({
   id: exports_external.string(),
@@ -14005,6 +14016,8 @@ var gatewayUsageResetRequestSchema = exports_external.object({
   bucketId: exports_external.string(),
   timeframe: gatewayUsageTimeframeSchema,
   policyName: exports_external.string(),
+  providerId: exports_external.string().nullable().optional(),
+  providerName: exports_external.string().nullable().optional(),
   reason: exports_external.string(),
   status: exports_external.enum(["pending", "approved", "denied", "expired"]),
   createdAt: exports_external.iso.datetime(),

package/dist/opencode-plugins/openwork-mcp-readiness-v2.js

@@ -0,0 +1,192 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/opencode-plugins/openwork-mcp-readiness-v2.ts
+import { Context, Effect, Option, Schema, Scope } from "effect";
+
+// src/opencode-v2-mcp-readiness.ts
+var MCP_READINESS_RPC_ID = "openwork.mcp-readiness";
+var mcpNamespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var mcpToolId = (server, name) => `${mcpNamespace(server)}_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+function mcpBindingsReady(current, server, desired, previous) {
+  const published = new Set(current.filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id));
+  const wanted = new Set(desired);
+  return desired.every((id) => published.has(id)) && previous.every((id) => wanted.has(id) || !published.has(id));
+}
+async function waitForMcpBindings(registry, server, desired, previous, signal) {
+  signal.throwIfAborted();
+  const current = await registry.list();
+  signal.throwIfAborted();
+  if (mcpBindingsReady(current, server, desired, previous))
+    return;
+  let closed = false;
+  let queued = false;
+  let registration;
+  let resolve = () => {};
+  let reject = () => {};
+  const ready = new Promise((accept, fail2) => {
+    resolve = accept;
+    reject = fail2;
+  });
+  ready.catch(() => {});
+  const fail = (error) => {
+    if (closed)
+      return;
+    closed = true;
+    reject(error);
+  };
+  const abort = () => fail(signal.reason ?? new Error("MCP readiness canceled"));
+  const observe = () => {
+    if (closed || queued)
+      return;
+    queued = true;
+    queueMicrotask(() => {
+      queued = false;
+      if (closed)
+        return;
+      registry.list().then((current2) => {
+        if (closed || !mcpBindingsReady(current2, server, desired, previous))
+          return;
+        closed = true;
+        resolve();
+      }, fail);
+    });
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    signal.throwIfAborted();
+    registration = await registry.transform(observe);
+    await ready;
+  } finally {
+    closed = true;
+    signal.removeEventListener("abort", abort);
+    await registration?.dispose();
+  }
+}
+
+// src/opencode-plugins/openwork-mcp-readiness-v2.ts
+class NativeMcp extends Context.Service()("@opencode/MCP") {
+}
+
+class NativeMcpTool extends Context.Service()("@opencode/McpTool") {
+}
+var serverSchema = { type: "string", minLength: 1 };
+var toolsSchema = { type: "array", maxItems: 4096, items: { type: "string", minLength: 1 } };
+var definition = {
+  id: MCP_READINESS_RPC_ID,
+  methods: {
+    catalog: {
+      input: { type: "object", properties: { server: serverSchema }, required: ["server"], additionalProperties: false },
+      output: { type: "object", properties: { tools: toolsSchema }, required: ["tools"], additionalProperties: false }
+    },
+    waitForTools: {
+      input: { type: "object", properties: { server: serverSchema }, required: ["server"], additionalProperties: false },
+      output: { type: "object", properties: { ready: { const: true } }, required: ["ready"], additionalProperties: false }
+    }
+  },
+  events: {}
+};
+var serverInput = Schema.Struct({ server: Schema.String });
+var inputServer = (input) => Schema.decodeUnknownSync(serverInput)(input).server;
+var nativeCatalog = Effect.gen(function* () {
+  const context = yield* Effect.context();
+  const mcp = Context.getOption(context, NativeMcp);
+  const source = Context.getOption(context, NativeMcpTool);
+  if (Option.isNone(mcp) || Option.isNone(source))
+    return yield* Effect.die(new Error("Native MCP readiness services are unavailable"));
+  yield* source.value.flush;
+  return mcp.value;
+});
+var waitForNativeMcpBindings = Effect.fn("OpenWorkMcp.waitForBindings")(function* (tool, server, desired, previous) {
+  const scope = yield* Scope.Scope;
+  yield* Effect.tryPromise({
+    try: (signal) => waitForMcpBindings({
+      list: () => Effect.runPromise(tool.list()),
+      transform: async (observe) => {
+        const registration = await Effect.runPromise(tool.transform(observe).pipe(Effect.provideService(Scope.Scope, scope)));
+        return { dispose: () => Effect.runPromise(registration.dispose) };
+      }
+    }, server, desired, previous, signal),
+    catch: (cause) => cause
+  });
+}, Effect.orDie);
+var openwork_mcp_readiness_v2_default = {
+  id: MCP_READINESS_RPC_ID,
+  effect: (ctx) => {
+    const supported = () => {
+      if (ctx.app.version !== "2.0.26")
+        throw new Error("Review the native MCP readiness bridge before changing the engine pin");
+    };
+    return ctx.rpc.register(definition, {
+      catalog: Effect.fn("OpenWorkMcp.catalog")(function* (input) {
+        supported();
+        const server = inputServer(input);
+        const mcp = yield* nativeCatalog;
+        const discovered = (yield* mcp.tools()).filter((tool) => tool.server === server).map((tool) => mcpToolId(server, tool.name));
+        const published = (yield* ctx.tool.list()).filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id);
+        return { tools: [...new Set([...discovered, ...published])].sort() };
+      }),
+      waitForTools: Effect.fn("OpenWorkMcp.waitForTools")(function* (input) {
+        supported();
+        const server = inputServer(input);
+        const mcp = yield* nativeCatalog;
+        yield* ctx.tool.reload();
+        const previous = (yield* ctx.tool.list()).filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id);
+        const target = (yield* mcp.servers()).find((item) => item.name === server);
+        if (target && !["connected", "disabled"].includes(target.status.status)) {
+          return yield* Effect.die(new Error(`MCP ${server} is ${target.status.status}, not executable`));
+        }
+        const desired = (yield* mcp.tools()).filter((tool) => tool.server === server).map((tool) => mcpToolId(server, tool.name));
+        yield* waitForNativeMcpBindings(ctx.tool, server, desired, previous).pipe(Effect.scoped);
+        return { ready: true };
+      })
+    }).pipe(Effect.asVoid);
+  }
+};
+export {
+  openwork_mcp_readiness_v2_default as default
+};