@desplega.ai/agent-swarm 1.146.0 → 1.147.0

package/dist/{cli-pmwbdw36.js → cli-hbv0kq6w.js}

@@ -4,11 +4,11 @@ import {
   getEmbeddingProvider,
   init_embedding,
   serializeEmbedding
-} from "./cli-pzfc7j7g.js";
+} from "./cli-1th1728g.js";
 import {
   getDbClient,
   init_db
-} from "./cli-d4xqde2b.js";
+} from "./cli-ftht3zzj.js";
 import {
   init_secret_scrubber,
   scrubSecrets

package/dist/{cli-fhsz3twr.js → cli-jsp14b6c.js}

@@ -310,4 +310,174 @@ function stripTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
 
-export { FilesError, providerPath, normalizeFilesError, AgentFsProvider };
+// src/fs/local-fs-provider.ts
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+var DEFAULT_ROOT_DIR = "./data/fs";
+
+class LocalFsProvider {
+  id = "local-fs";
+  capabilities = {
+    signedUrl: { supported: false }
+  };
+  rootDir;
+  constructor(options = {}) {
+    this.rootDir = options.rootDir ?? process.env.AGENT_FS_LOCAL_DIR ?? DEFAULT_ROOT_DIR;
+  }
+  async upload(scope, body, options = {}) {
+    const target = this.localPath(scope);
+    await mkdir(dirname(target), { recursive: true });
+    if (options.ifNoneMatch === "*" && await this.exists(scope)) {
+      throw new FilesError("Conflict", "File already exists");
+    }
+    await Bun.write(target, await new Response(body).arrayBuffer());
+    if (options.contentType) {
+      await Bun.write(this.metaPath(target), JSON.stringify({ contentType: options.contentType }));
+    }
+    return this.head(scope);
+  }
+  async download(scope) {
+    const target = this.localPath(scope);
+    if (!await this.exists(scope)) {
+      throw new FilesError("NotFound", "File not found");
+    }
+    return new Response(Bun.file(target));
+  }
+  async head(scope) {
+    const target = this.localPath(scope);
+    try {
+      const info = await stat(target);
+      const storedContentType = await this.readStoredContentType(target);
+      return {
+        providerId: this.id,
+        key: providerPath(scope),
+        taskId: scope.taskId,
+        name: scope.name,
+        contentType: storedContentType ?? Bun.file(target).type ?? undefined,
+        sizeBytes: info.size,
+        updatedAt: info.mtime.toISOString()
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new FilesError("NotFound", "File not found", { cause: error });
+      }
+      throw new FilesError("Provider", "Unable to read file metadata", { cause: error });
+    }
+  }
+  async exists(scope) {
+    try {
+      await stat(this.localPath(scope));
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw new FilesError("Provider", "Unable to check file existence", { cause: error });
+    }
+  }
+  async delete(scope) {
+    const target = this.localPath(scope);
+    await rm(target, { force: true });
+    await rm(this.metaPath(target), { force: true });
+  }
+  async copy(source, destination) {
+    const sourceHead = await this.head(source);
+    const response = await this.download(source);
+    await this.upload(destination, await response.arrayBuffer(), {
+      contentType: sourceHead.contentType
+    });
+    return this.head(destination);
+  }
+  async move(source, destination) {
+    const copied = await this.copy(source, destination);
+    await this.delete(source);
+    return copied;
+  }
+  async list(options) {
+    const taskRoot = join(this.rootDir, "tasks", encodeURIComponent(options.taskId));
+    const files = [];
+    await this.walk(taskRoot, async (path) => {
+      const rel = relative(taskRoot, path).split(sep).join("/");
+      const name = decodePath(rel);
+      if (options.prefix && !name.startsWith(options.prefix)) {
+        return;
+      }
+      files.push(await this.head({ taskId: options.taskId, name }));
+    });
+    return typeof options.limit === "number" ? files.slice(0, options.limit) : files;
+  }
+  async* listAll(options) {
+    for (const item of await this.list(options)) {
+      yield item;
+    }
+  }
+  async url(scope) {
+    return `/api/fs/tasks/${encodeURIComponent(scope.taskId)}/files/${encodeURIComponent(scope.name)}/raw`;
+  }
+  async signedUploadUrl() {
+    throw new FilesError("ReadOnly", "local-fs does not support signed upload URLs");
+  }
+  localPath(scope) {
+    return join(this.rootDir, providerPath(scope));
+  }
+  metaPath(target) {
+    return `${target}.meta.json`;
+  }
+  async readStoredContentType(target) {
+    try {
+      const metaFile = Bun.file(this.metaPath(target));
+      if (!await metaFile.exists()) {
+        return;
+      }
+      const meta = await metaFile.json();
+      return typeof meta?.contentType === "string" ? meta.contentType : undefined;
+    } catch {
+      return;
+    }
+  }
+  async walk(dir, visit) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw new FilesError("Provider", "Unable to list files", { cause: error });
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walk(path, visit);
+      } else if (entry.isFile() && !entry.name.endsWith(".meta.json")) {
+        await visit(path);
+      }
+    }
+  }
+}
+function decodePath(path) {
+  return path.split("/").map((part) => decodeURIComponent(part)).join("/");
+}
+
+// src/fs/registry.ts
+var memoizedProvider = null;
+function getFileStorageProvider() {
+  if (!memoizedProvider) {
+    memoizedProvider = selectProvider();
+  }
+  return memoizedProvider;
+}
+function selectProvider() {
+  if (process.env.AGENT_FS_API_URL && (process.env.API_AGENT_FS_API_KEY || process.env.AGENT_FS_API_KEY)) {
+    return new AgentFsProvider;
+  }
+  return new LocalFsProvider;
+}
+function resetFileStorageProvider() {
+  memoizedProvider = null;
+}
+function resetFileStorageProviderForTests() {
+  resetFileStorageProvider();
+}
+
+export { FilesError, providerPath, normalizeFilesError, AgentFsProvider, getFileStorageProvider, selectProvider, resetFileStorageProvider, resetFileStorageProviderForTests };

package/dist/{cli-2zvtzevh.js → cli-kpv03zhj.js}

@@ -6,6 +6,14 @@ import {
   __esm
 } from "./cli-bc05qbss.js";
 
+// src/utils/steering-enabled.ts
+function isSteeringEnabled(env = process.env) {
+  return parseEnvFlag(env.STEERING_ENABLED, false);
+}
+var init_steering_enabled = __esm(() => {
+  init_env_flag();
+});
+
 // src/utils/template.ts
 function findInterpolationTokens(template) {
   return Array.from(template.matchAll(INTERPOLATION_TOKEN_RE), (match) => match[1].trim());
@@ -223,14 +231,6 @@ var init_resolver = __esm(() => {
   TEMPLATE_REF_REGEX = /\{\{@template\[([^\]]+)\]\}\}/g;
 });
 
-// src/utils/steering-enabled.ts
-function isSteeringEnabled(env = process.env) {
-  return parseEnvFlag(env.STEERING_ENABLED, false);
-}
-var init_steering_enabled = __esm(() => {
-  init_env_flag();
-});
-
 // src/prompts/session-templates.ts
 var compositeVariables;
 var init_session_templates = __esm(() => {
@@ -270,7 +270,8 @@ Choose the path by the shape of the work:
 Store progress with \`store-progress\` at each milestone. A milestone is a result the lead could act on.
 The task is done when \`store-progress\` carries status \`completed\` and an \`output\` that names the result and every artifact link. On failure, status \`failed\` and a \`failureReason\` that names what you tried.
 When the task carries an \`outputSchema\`, \`output\` is JSON that matches it.
-When you are blocked after real effort, store the blocker with \`store-progress\` and keep working on what you can. When nothing is left to do, fail the task with a \`failureReason\` that names the blocker. The lead reads both.
+When you are blocked after real effort, store the blocker with \`store-progress\` and keep working on what you can.
+The task has four endings. When you are done: \`completed\`. When the answer needs time (a build, a deploy, a reply): \`defer-task\` with a summary of what you did, when to wake up, and what to check. It completes the task now; the wake-up task continues it. When a person must decide: \`request-human-input\`. When nothing else is possible: \`failed\` with the blocker.
 `,
     variables: [],
     category: "system"
@@ -284,9 +285,10 @@ When you are blocked after real effort, store the blocker with \`store-progress\
 Your output is delegation and review. Workers implement, research, analyze, and write. Data gathering, even a quick query, goes to a worker. You answer simple factual questions yourself.
 
 \`get-swarm\` is the roster. Route by capability and load.
+Delegate with \`send-task\`. Read a child's result with \`get-task-details\`.
 A task states the goal, the repo URL when there is one, and the constraints. Workers know git, the skills, and \`store-progress\`.
 Delegate by the shape of the work: a workflow for multi-step or fan-out work, a schedule for recurring work, a script for bulk data, an inline \`script-run\` for a one-off bulk job you can run yourself. The \`workflow-iterate\`, \`scheduling\`, and \`swarm-scripts\` skills build them.
-Research or exploration: tell the worker to use \`/researching\`. A large feature: a \`/planning\` task first, then an \`/implementing\` task with \`parentTaskId\`. A small fix: direct implementation.
+Research or exploration: tell the worker to use the \`researching\` skill. A large feature: a task for the \`planning\` skill first, then a task for the \`implementing\` skill with \`parentTaskId\`. A small fix: direct implementation.
 A follow-up that continues earlier work carries \`parentTaskId\`. The worker receives the prior context.
 A task whose result depends on the workers' output: wait for the children with the \`wait-for-task\` script, then merge and complete the task yourself. A turn that ends with children still running leaves the task unfinished.
 
@@ -657,4 +659,4 @@ If this task reveals new stable communication preferences for this requester, pe
   });
 });
 
-export { findInterpolationTokens, interpolate, deepInterpolate, init_template, registerTemplate, getTemplateDefinition, getAllTemplateDefinitions, init_registry, configureDbResolver, configureHttpResolver, resolveTemplate, resolveTemplateAsync, init_resolver, isSteeringEnabled, init_steering_enabled, init_session_templates };
+export { isSteeringEnabled, init_steering_enabled, findInterpolationTokens, interpolate, deepInterpolate, init_template, registerTemplate, getTemplateDefinition, getAllTemplateDefinitions, init_registry, configureDbResolver, configureHttpResolver, resolveTemplate, resolveTemplateAsync, init_resolver, init_session_templates };

package/dist/{cli-a9bn9svs.js → cli-m8yrsg97.js}

@@ -1,14 +1,14 @@
 import {
   buildModelsDevSeedRows,
   loadModelsDevCache
-} from "./cli-yqeb27t1.js";
+} from "./cli-rw51bq3j.js";
 import {
   createLogEntry,
   getActivePricingRow,
   getDbClient,
   init_db,
   insertPricingRow
-} from "./cli-d4xqde2b.js";
+} from "./cli-ftht3zzj.js";
 import {
   init_secret_scrubber,
   scrubSecrets