@zackbart/connecta 0.34.0 → 0.35.0

package/dist/routes/ui-data.js

@@ -21,9 +21,6 @@ function attempt(operation) {
 }
 export function uiData(registry, baseUrl, options) {
     return Effect.suspend(() => {
-        const requestScope = {};
-        if (options.activityContext)
-            bindActivityRequest(requestScope, options.activityContext);
         const vault = options.credentialVault;
         const owner = options.personalCredentialOwner;
         /**
@@ -34,7 +31,7 @@ export function uiData(registry, baseUrl, options) {
          * `status()` can quote a downstream error body, which can quote the
          * secret it just rejected (INV-6). An `ok` status is simply dropped.
          */
-        const logStatus = (id, state, failure) => {
+        const logStatus = (id, state, failure, requestScope) => {
             if (state === "ok")
                 return;
             const logger = registry.contextFor(id, baseUrl, requestScope).logger;
@@ -43,7 +40,7 @@ export function uiData(registry, baseUrl, options) {
         // Status first, then the catalog only when status is ok. A failed status
         // read is an error status, not a failed row: the row still reports the
         // connector's credential.
-        const observe = (c, drift, signal) => {
+        const observe = (c, drift, signal, requestScope) => {
             if (drift) {
                 return Effect.succeed({
                     status: { state: "auth_required", message: drift },
@@ -74,7 +71,13 @@ export function uiData(registry, baseUrl, options) {
                 }))).pipe(Effect.map((tools) => ({ status, tools, catalogFailed: false })), 
                 // The registry owns the failed catalog observation; the page only
                 // needs to know there was one.
-                Effect.catch(() => Effect.succeed({ status, tools: [], catalogFailed: !signal.aborted })));
+                Effect.catch(() => Effect.succeed({ status, tools: [], catalogFailed: !signal.aborted })), 
+                // Loading the catalog may replace an earlier clean observation.
+                // Read this view's current bounded facts without another status probe.
+                Effect.map((observed) => ({
+                    ...observed,
+                    status: registry.withCatalogObservations(c.id, baseUrl, observed.status),
+                })));
             }).pipe(Effect.catch((error) => Effect.succeed({
                 status: failureStatus(c.id, error),
                 tools: [],
@@ -146,14 +149,14 @@ export function uiData(registry, baseUrl, options) {
                 });
             }));
         };
-        const detail = (c, signal) => Effect.gen(function* () {
+        const detail = (c, signal, requestScope) => Effect.gen(function* () {
             const drift = yield* attempt(() => registry.credentialDriftFor(c.id));
             // One deadline covers the whole row. The status and catalog reads once
             // had a second one of the same length inside it, which could only fire
             // after this one had already ended the row.
-            const { status, tools, catalogFailed } = yield* observe(c, drift, signal);
+            const { status, tools, catalogFailed } = yield* observe(c, drift, signal, requestScope);
             const credential = yield* credentialFor(c);
-            logStatus(c.id, status.state, statusFailure(status));
+            logStatus(c.id, status.state, statusFailure(status), requestScope);
             const problem = uiProblemFor(c, status.state, {
                 credentialDrift: Boolean(drift),
                 catalogFailed,
@@ -168,10 +171,7 @@ export function uiData(registry, baseUrl, options) {
                 toolCount: tools.length,
                 tools,
                 // Counts only, and only when a refresh in this runtime produced them.
-                // `Registry.statusFor` already rebuilt the report through
-                // `boundedCatalogDrift`, so what lands here cannot carry a name or a
-                // schema even if the plugin seam returned one.
-                ...(status.catalogDrift ? { catalogDrift: status.catalogDrift } : {}),
+                // `Registry.withCatalogObservations` rebuilt the report through
                 ...(status.catalogAccess ? { catalogAccess: status.catalogAccess } : {}),
                 ...(status.resourceTemplateRefusals ? { resourceTemplateRefusals: status.resourceTemplateRefusals } : {}),
                 ...(status.state === "auth_required" && c.startAuth && options.mayManage?.(c.id) && options.oauthConnectUrl
@@ -182,8 +182,8 @@ export function uiData(registry, baseUrl, options) {
                 ...(credential ? { credential } : {}),
             };
         });
-        const unavailable = (c, error) => Effect.sync(() => {
-            logStatus(c.id, "failed", error);
+        const unavailable = (c, error, requestScope) => Effect.sync(() => {
+            logStatus(c.id, "failed", error, requestScope);
             return {
                 id: c.id,
                 ...(c.title ? { title: c.title } : {}),
@@ -195,13 +195,20 @@ export function uiData(registry, baseUrl, options) {
                 tools: [],
             };
         });
-        const row = (c) => withDeadlineEffect((signal) => detail(c, signal), {
-            timeoutMs: options.timeoutMs ?? DETAIL_TIMEOUT_MS,
-            ...(options.signal ? { signal: options.signal } : {}),
-            timeoutError: new Error(DETAIL_TIMED_OUT),
-        }).pipe(
-        // A hook that throws where it should reject fails its own row too.
-        Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => unavailable(c, error)), Effect.ensuring(Effect.suspend(() => closeScope(c, registry.contextFor(c.id, baseUrl, requestScope), options.defer))));
+        const row = (c) => Effect.suspend(() => {
+            // A row ends independently. Revoking its probe must not revoke a live
+            // sibling that happens to belong to the same operator payload.
+            const requestScope = {};
+            if (options.activityContext)
+                bindActivityRequest(requestScope, options.activityContext);
+            return withDeadlineEffect((signal) => detail(c, signal, requestScope), {
+                timeoutMs: options.timeoutMs ?? DETAIL_TIMEOUT_MS,
+                ...(options.signal ? { signal: options.signal } : {}),
+                timeoutError: new Error(DETAIL_TIMED_OUT),
+            }).pipe(
+            // A hook that throws where it should reject fails its own row too.
+            Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => unavailable(c, error, requestScope)), Effect.ensuring(Effect.suspend(() => closeScope(c, registry.contextFor(c.id, baseUrl, requestScope), options.defer))));
+        });
         return Effect.forEach(registry.listConnectors(), row, {
             concurrency: resolveDiscoveryConcurrency(options.discoveryConcurrency),
         }).pipe(Effect.map((connectors) => ({

package/dist/routes/ui.js

@@ -74,7 +74,7 @@ export async function routeUi(context) {
     const operatorPage = operatorPageForPath(path);
     if (operatorPage &&
         (operatorPage !== "activity" || opts.config.activity?.store.list) &&
-        (operatorPage !== "tokens" || opts.config.accessTokens)) {
+        (operatorPage !== "tokens" || opts.config.accessTokens || opts.config.agents.length > 0)) {
         if (request.method !== "GET" && request.method !== "HEAD") {
             return privateJson({ error: "method not allowed" }, { status: 405 });
         }

package/dist/runtime/call-admission.js

@@ -50,29 +50,3 @@ function installed() {
 export function startCallAdmission(controller, request) {
     return installed()(controller, request, liveNow);
 }
-/**
- * Admit one downstream call, as `controller.acquire()` does, without a
- * Promise.
- *
- * Fails with the same CallAdmissionError objects and bumps the same counters.
- * The rolling window and queue-wait times read the fiber's Clock. Nothing
- * happens until the effect runs, and each run is a fresh admission.
- * Interrupting the fiber while it is queued withdraws it (counted as
- * cancelled); interrupting it after a slot was handed over releases that slot
- * rather than stranding it.
- */
-export function admitCall(controller, request) {
-    const admit = installed();
-    return Effect.clockWith((clock) => admit(controller, request, () => clock.currentTimeMillisUnsafe()));
-}
-/**
- * A permit owned by the enclosing Scope: released when the scope closes, on
- * success, failure, or interruption alike. The queued wait stays
- * interruptible, so a caller that left does not hold its place in line until
- * the queue timeout.
- */
-export function acquireCallScoped(controller, request) {
-    return Effect.acquireRelease(admitCall(controller, request), (permit) => Effect.sync(() => permit.release()), {
-        interruptible: true,
-    });
-}

package/dist/runtime/call-entry.js

@@ -0,0 +1,30 @@
+import { originalCallIdentity } from "../provider-call-facts.js";
+import { Effect } from "effect";
+import { ActiveCall, Operation, contextView, duringViewEffect } from "./call.js";
+const entries = new WeakMap();
+export function registerCallEntry(connector, core) {
+    entries.set(connector, {
+        own: connector.callTool,
+        run: (name, args, options) => Effect.gen(function* () {
+            const lease = yield* ActiveCall;
+            const operation = yield* Operation;
+            if (!operation)
+                return yield* Effect.die(new Error("An api call needs its operation services."));
+            const services = yield* Effect.context();
+            const view = contextView({ ...lease, services }, operation);
+            return yield* duringViewEffect(view, () => core(name, args, view, options));
+        }),
+    });
+}
+export function callEntry(connector, own) {
+    const entry = entries.get(originalCallIdentity(connector));
+    return entry?.own === own ? entry.run : undefined;
+}
+const tools = new WeakMap();
+export function registerToolEntry(tool, run) {
+    tools.set(tool, { own: tool.handler, run });
+}
+export function toolEntry(tool) {
+    const entry = tools.get(tool);
+    return entry?.own === tool.handler ? entry.run : undefined;
+}