@axiom-lattice/core 6.3.0 → 6.3.2

package/dist/index.mjs

@@ -18552,12 +18552,47 @@ var Agent = class {
           id: interruptData.id,
           data: { content: interruptData.value }
         };
+        await this.awaitDurableInterrupt(interruptData.id, signal);
       }
       if (data) {
         this.addChunk(data);
       }
     }
   }
+  /**
+   * Waits until the thread's durable checkpoint reports the given interrupt id.
+   *
+   * Reads {@link getCurrentState} (the checkpoint, i.e. the single source of
+   * truth), never an in-memory status, so a `true` result guarantees a resume
+   * against this thread will find the interrupt. Bounded so a broken
+   * checkpointer cannot strand the stream; on timeout the interrupt is emitted
+   * anyway and a warning is logged.
+   *
+   * @param interruptId - Interrupt id from the streamed `__interrupt__` update.
+   * @param signal - Run abort signal; polling stops when aborted.
+   * @param timeoutMs - Maximum time to wait for durable confirmation.
+   */
+  async awaitDurableInterrupt(interruptId, signal, timeoutMs = 5e3) {
+    if (!interruptId) return;
+    const deadline = Date.now() + timeoutMs;
+    while (!signal?.aborted) {
+      try {
+        const state = await this.getCurrentState();
+        const durable = (state?.tasks ?? []).some(
+          (task) => (task.interrupts ?? []).some((interrupt5) => interrupt5.id === interruptId)
+        );
+        if (durable) return;
+      } catch {
+      }
+      if (Date.now() >= deadline) {
+        console.warn(
+          `[Agent] interrupt ${interruptId} not durable within ${timeoutMs}ms on thread ${this.thread_id}; emitting without durable confirmation`
+        );
+        return;
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, 20));
+    }
+  }
   /**
    * Resume LangGraph execution from the last checkpoint.
    *
@@ -40139,6 +40174,33 @@ function clearEncryptionKeyCache() {
   cachedKey = null;
   keyValidated = false;
 }
+function encryptConfigFields(config, fields) {
+  if (!fields?.length) return config;
+  const out = { ...config };
+  for (const field of fields) {
+    const value = out[field];
+    if (typeof value === "string" && value.length > 0) {
+      out[field] = encrypt(value);
+    }
+  }
+  return out;
+}
+function decryptConfigFields(config, fields) {
+  if (!fields?.length) return config;
+  const out = { ...config };
+  for (const field of fields) {
+    const value = out[field];
+    if (typeof value === "string" && value.length > 0) {
+      try {
+        out[field] = decrypt(value);
+      } catch (error) {
+        console.error(`Failed to decrypt connection field "${field}":`, error);
+        throw new Error("Failed to decrypt connection configuration");
+      }
+    }
+  }
+  return out;
+}
 
 // src/util/safeUpstreamUrl.ts
 var UnsafeUpstreamUrlError = class extends Error {
@@ -43672,7 +43734,7 @@ function createTaskMiddleware(options = {}) {
           error: "Task changed before activity could be recorded."
         });
         markMutation();
-        return JSON.stringify({ success: true, data: activity });
+        return JSON.stringify({ success: true, data: activity, task: existing });
       }
       case "update": {
         taskUpdateDebug("update:enter", {
@@ -46163,6 +46225,12 @@ import { createMiddleware as createMiddleware27, tool as tool67 } from "langchai
 import { z as z73 } from "zod";
 import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 
+// src/connection/connectionSecretFields.ts
+function connectionSecretFields(plugin) {
+  const fields = plugin?.connection?.fields ?? [];
+  return fields.filter((field) => field.type === "password" || field.widget === "password").map((field) => field.key);
+}
+
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
   "schemaVersion": 1,
@@ -46826,11 +46894,25 @@ Use the \`manage_plugin\` tool. The loop:
 
 1. \`action: "validate"\` with \`{ type, manifest, handlers }\` \u2014 dry-run, no writes, returns diagnostics.
 2. \`action: "create"\` or \`"update"\` \u2014 writes files, bumps version, reloads.
-3. \`action: "test"\` to exercise a handler without an LLM:
+3. If the plugin has \`connection.fields\` and a tool reads credentials: a **human**
+   must configure a connection of this plugin type. You cannot create credentials.
+   Call \`list_connections { type }\` first \u2014 if none exist, use \`ask_user_to_clarify\`
+   to state explicitly that only the human can configure the connector, ask them to
+   add it (Console \u2192 Connections) and to give you the connection key. Do not claim
+   the tool works until a real \`connectionKey\` test passes.
+4. \`action: "test"\` to exercise a handler without an LLM:
    - Tool: \`{ type, target: { kind: "tool", name, input, connectionKey? } }\`
    - Connection: \`{ type, target: { kind: "connection-test" } }\` or \`{ kind: "connection-discover" }\`
    Returns \`{ ok, result, exitCode, durationMs, stdout, stderr }\`.
-4. \`action: "reload"\` if you edited files directly.
+   For credentialed tools, pass the real \`connectionKey\`. Without one, the handler
+   receives an empty connection \u2014 that only checks plumbing, NOT functional success.
+5. \`action: "reload"\` if you edited files directly.
+
+## Secrets
+- \`list_connections\` returns identifiers only (\`key\`/\`name\`/\`description\`), never config or secrets.
+- \`test\` output is redacted: real connection secret values are replaced with
+  \`[redacted]\`. Never rely on echoing credentials to verify a handler \u2014 assert on
+  functional output instead.
 
 ## Common failures
 | Symptom | Cause |
@@ -46840,9 +46922,12 @@ Use the \`manage_plugin\` tool. The loop:
 | TOOL_SCHEMA | unsupported JSON Schema keyword |
 | non-zero exit | handler threw; read stdout/stderr from \`test\` |
 | old behaviour after edit | version/hash unchanged \u2014 bump \`version\` or call \`reload\` |
+| empty connection in handler | no \`connectionKey\` passed, or no connection configured for this type |
 
 Fall back to \`execute_code\`/\`shell\` to run \`node handlers/x.js\` manually with
-\`PLUGIN_INPUT\` set if you need to reproduce.
+\`PLUGIN_INPUT\` and a synthetic \`PLUGIN_CONNECTION_FILE\` to reproduce logic bugs.
+A synthetic fixture only verifies plumbing \u2014 a real upstream call requires a real
+\`connectionKey\` configured by a human.
 `,
     resources: {}
   }
@@ -46873,8 +46958,13 @@ implemented", "UI added", "validated/tested via manage_plugin"). As you work,
 update each Task's status to reflect reality. Never use \`write_todos\`.
 
 Author with the \`manage_plugin\` tool: validate, then create/update, then test.
-Use \`shell_exec\` (the tool provided by the \`code_eval\` middleware) to run
-\`node handlers/x.js\` for manual checks when reproducing a failure.`;
+If a tool needs credentials, a human must configure the connection \u2014 use
+\`list_connections\` to check, and \`ask_user_to_clarify\` to ask the human to add
+the connector and give you its key. Only after a real \`connectionKey\` test
+passes may you call the tool verified; without it, report functionality as
+unverified (missing credentials), not as passing. Use \`shell_exec\` (the tool
+provided by the \`code_eval\` middleware) to run \`node handlers/x.js\` for manual
+checks when reproducing a failure.`;
 
 // src/middlewares/sandboxPluginsMiddleware.ts
 var PLUGIN_BUILDER_SKILLS = [...Object.keys(SANDBOX_PLUGIN_SKILLS), "task-tracking"];
@@ -46882,6 +46972,37 @@ function tenantIdFrom(exeConfig) {
   const c = exeConfig;
   return c?.configurable?.runConfig?.tenantId ?? "default";
 }
+function collectSecretValues(connection, fields) {
+  if (!connection) return [];
+  const values = [];
+  for (const field of fields) {
+    const value = connection[field];
+    if (typeof value === "string" && value.length > 0) values.push(value);
+  }
+  return values;
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function redactString(value, secrets) {
+  let out = value;
+  for (const secret of secrets) out = out.split(secret).join("[redacted]");
+  return out;
+}
+function redactSecretValues(payload, secrets) {
+  if (secrets.length === 0) return payload;
+  const walk = (node) => {
+    if (typeof node === "string") return redactString(node, secrets);
+    if (Array.isArray(node)) return node.map(walk);
+    if (node !== null && typeof node === "object") {
+      const out = {};
+      for (const [key5, value] of Object.entries(node)) out[key5] = walk(value);
+      return out;
+    }
+    return node;
+  };
+  return walk(payload);
+}
 var managePluginSchema = z73.object({
   action: z73.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
   type: z73.string().optional(),
@@ -46913,6 +47034,10 @@ var sandboxPluginsPlugin = {
       description: "Author and manage tenant plugins in the shared sandbox: clarify goal, inputs/outputs, credentials, and whether a UI is needed; then write the manifest and JS handlers, add an optional HTML MCP App UI, and validate/test with the manage_plugin tool.",
       type: AgentType10.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
+      // Read-only discovery of connection identifiers (metadata only — never
+      // config/secrets) so the builder can confirm a human configured a
+      // connector and pass its key to `manage_plugin test`.
+      tools: ["list_connections"],
       middleware: [
         {
           id: "sandbox-plugins",
@@ -47048,8 +47173,19 @@ var sandboxPluginsPlugin = {
                   input.target.connectionKey ? { connections: [input.target.connectionKey] } : { connectAll: true },
                   { tenantId: tenantId2 }
                 );
-                const result2 = await plugin.connection?.test?.(connection ?? {});
-                return JSON.stringify(result2 ?? { ok: false, message: "no test handler" });
+                const secrets2 = collectSecretValues(connection, connectionSecretFields(plugin));
+                try {
+                  const result = await plugin.connection?.test?.(connection ?? {});
+                  return JSON.stringify(redactSecretValues(
+                    result ?? { ok: false, message: "no test handler" },
+                    secrets2
+                  ));
+                } catch (err) {
+                  return JSON.stringify(redactSecretValues(
+                    { ok: false, message: errorText(err) },
+                    secrets2
+                  ));
+                }
               }
               if (input.target.kind === "connection-discover") {
                 const { connection } = await resolveSandboxPluginConnections(
@@ -47057,8 +47193,16 @@ var sandboxPluginsPlugin = {
                   input.target.connectionKey ? { connections: [input.target.connectionKey] } : { connectAll: true },
                   { tenantId: tenantId2 }
                 );
-                const result2 = await plugin.connection?.discover?.(connection ?? {});
-                return JSON.stringify(result2 ?? []);
+                const secrets2 = collectSecretValues(connection, connectionSecretFields(plugin));
+                try {
+                  const result = await plugin.connection?.discover?.(connection ?? {});
+                  return JSON.stringify(redactSecretValues(result ?? [], secrets2));
+                } catch (err) {
+                  return JSON.stringify(redactSecretValues(
+                    { error: errorText(err) },
+                    secrets2
+                  ));
+                }
               }
               const executor = catalog2.getExecutor();
               const manifestContent = await catalog2.readPluginFile(tenantId2, input.type, "plugin.json");
@@ -47076,19 +47220,24 @@ var sandboxPluginsPlugin = {
                 { connections: [input.target.connectionKey] },
                 { tenantId: tenantId2 }
               ) : {};
-              const result = await executor.invoke({
-                manifest: parsedManifest,
-                handler: toolDef.handler,
-                input: input.target.input ?? null,
-                connection: resolved.connection,
-                connections: resolved.connections,
-                context: { tenantId: tenantId2, pluginType: input.type, tool: toolDef.name },
-                runConfig: {
-                  tenantId: tenantId2,
-                  assistantId: typeof runCfg.assistant_id === "string" ? runCfg.assistant_id : void 0
-                }
-              });
-              return JSON.stringify(result);
+              const secrets = collectSecretValues(resolved.connection, connectionSecretFields(plugin));
+              try {
+                const result = await executor.invoke({
+                  manifest: parsedManifest,
+                  handler: toolDef.handler,
+                  input: input.target.input ?? null,
+                  connection: resolved.connection,
+                  connections: resolved.connections,
+                  context: { tenantId: tenantId2, pluginType: input.type, tool: toolDef.name },
+                  runConfig: {
+                    tenantId: tenantId2,
+                    assistantId: typeof runCfg.assistant_id === "string" ? runCfg.assistant_id : void 0
+                  }
+                });
+                return JSON.stringify(redactSecretValues(result, secrets));
+              } catch (err) {
+                return JSON.stringify(redactSecretValues({ ok: false, error: errorText(err) }, secrets));
+              }
             }
             default:
               return `unsupported action: ${input.action}`;
@@ -47751,6 +47900,7 @@ export {
   configurePluginCatalogSync,
   configureStores,
   connectAllChannels,
+  connectionSecretFields,
   convertToConnection,
   createAgentNode,
   createAgentTeam,
@@ -47791,11 +47941,13 @@ export {
   createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
+  decryptConfigFields,
   describeCronExpression,
   documentLearningPlugin,
   documentParserPlugin,
   embeddingsLatticeManager,
   encrypt,
+  encryptConfigFields,
   ensureBuiltinAgentsForTenant,
   ensurePluginSkillInSandbox,
   evaluateLatticeCaseWithLogs,