@pi-ohm/config 0.6.3 → 0.6.4-dev.22132458683.1.8646f56

package/README.md

@@ -11,3 +11,11 @@ Responsibilities:
   - `${configDir}/ohm.json`
   - `${configDir}/ohm.providers.json`
 - expose typed runtime config helpers to feature packages
+
+Subagents runtime config highlights:
+
+- `subagents.taskMaxConcurrency`
+- `subagents.taskRetentionMs`
+- `subagents.permissions.default` (`allow|deny`)
+- `subagents.permissions.subagents` (per-subagent overrides)
+- `subagents.permissions.allowInternalRouting`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-ohm/config",
-  "version": "0.6.3",
+  "version": "0.6.4-dev.22132458683.1.8646f56",
   "homepage": "https://github.com/pi-ohm/pi-ohm/tree/dev/packages/config#readme",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -38,11 +38,22 @@ export interface OhmPainterProviders {
   };
 }
 
+export interface OhmSubagentRuntimeConfig {
+  taskMaxConcurrency: number;
+  taskRetentionMs: number;
+  permissions: {
+    default: "allow" | "deny";
+    subagents: Record<string, "allow" | "deny">;
+    allowInternalRouting: boolean;
+  };
+}
+
 export interface OhmRuntimeConfig {
   defaultMode: OhmMode;
   subagentBackend: OhmSubagentBackend;
   features: OhmFeatureFlags;
   painter: OhmPainterProviders;
+  subagents?: OhmSubagentRuntimeConfig;
 }
 
 export interface OhmConfigPaths {
@@ -84,6 +95,15 @@ const DEFAULT_OHM_CONFIG: OhmRuntimeConfig = {
       apiVersion: "2025-04-01-preview",
     },
   },
+  subagents: {
+    taskMaxConcurrency: 3,
+    taskRetentionMs: 1000 * 60 * 60 * 24,
+    permissions: {
+      default: "allow",
+      subagents: {},
+      allowInternalRouting: false,
+    },
+  },
 };
 
 type JsonMap = Record<string, unknown>;
@@ -156,6 +176,41 @@ function normalizeString(value: unknown, fallback: string): string {
   return fallback;
 }
 
+function normalizePositiveInteger(value: unknown, fallback: number): number {
+  if (typeof value !== "number") return fallback;
+  if (!Number.isInteger(value) || value <= 0) return fallback;
+  return value;
+}
+
+function normalizePermissionDecision(value: unknown, fallback: "allow" | "deny"): "allow" | "deny" {
+  if (value === "allow" || value === "deny") return value;
+
+  // Legacy compatibility: treat deprecated "ask" as deny-safe behavior.
+  if (value === "ask") return "deny";
+
+  return fallback;
+}
+
+function normalizePermissionDecisionMap(
+  value: unknown,
+  fallback: Record<string, "allow" | "deny">,
+): Record<string, "allow" | "deny"> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fallback;
+  }
+
+  const normalized: Record<string, "allow" | "deny"> = {};
+  for (const [key, decision] of Object.entries(value)) {
+    const trimmedKey = key.trim().toLowerCase();
+    if (trimmedKey.length === 0) continue;
+
+    const normalizedDecision = normalizePermissionDecision(decision, "allow");
+    normalized[trimmedKey] = normalizedDecision;
+  }
+
+  return normalized;
+}
+
 function mergeConfig(base: OhmRuntimeConfig, patch: JsonMap): OhmRuntimeConfig {
   const next: OhmRuntimeConfig = structuredClone(base);
 
@@ -232,6 +287,64 @@ function mergeConfig(base: OhmRuntimeConfig, patch: JsonMap): OhmRuntimeConfig {
     next.painter.azureOpenai.apiVersion,
   );
 
+  const subagentPatch =
+    patch.subagents && typeof patch.subagents === "object"
+      ? (patch.subagents as JsonMap)
+      : undefined;
+
+  const subagentDefaults =
+    next.subagents ??
+    ({
+      taskMaxConcurrency: DEFAULT_OHM_CONFIG.subagents?.taskMaxConcurrency ?? 3,
+      taskRetentionMs: DEFAULT_OHM_CONFIG.subagents?.taskRetentionMs ?? 1000 * 60 * 60 * 24,
+      permissions: {
+        default: DEFAULT_OHM_CONFIG.subagents?.permissions.default ?? "allow",
+        subagents: DEFAULT_OHM_CONFIG.subagents?.permissions.subagents ?? {},
+        allowInternalRouting:
+          DEFAULT_OHM_CONFIG.subagents?.permissions.allowInternalRouting ?? false,
+      },
+    } satisfies OhmSubagentRuntimeConfig);
+
+  const taskMaxConcurrency = normalizePositiveInteger(
+    subagentPatch?.taskMaxConcurrency,
+    subagentDefaults.taskMaxConcurrency,
+  );
+
+  const taskRetentionMs = normalizePositiveInteger(
+    subagentPatch?.taskRetentionMs,
+    subagentDefaults.taskRetentionMs,
+  );
+
+  const permissionsPatch =
+    subagentPatch?.permissions && typeof subagentPatch.permissions === "object"
+      ? (subagentPatch.permissions as JsonMap)
+      : undefined;
+
+  const permissionsDefault = normalizePermissionDecision(
+    permissionsPatch?.default,
+    subagentDefaults.permissions.default,
+  );
+
+  const permissionsSubagents = normalizePermissionDecisionMap(
+    permissionsPatch?.subagents,
+    subagentDefaults.permissions.subagents,
+  );
+
+  const allowInternalRouting = normalizeBoolean(
+    permissionsPatch?.allowInternalRouting,
+    subagentDefaults.permissions.allowInternalRouting,
+  );
+
+  next.subagents = {
+    taskMaxConcurrency,
+    taskRetentionMs,
+    permissions: {
+      default: permissionsDefault,
+      subagents: permissionsSubagents,
+      allowInternalRouting,
+    },
+  };
+
   return next;
 }