@aionis/openclaw-adapter 0.1.0

package/dist/client/aionis-http-client.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMEOUT_MS = 20_000;
+export class AionisHttpClientError extends Error {
+    status;
+    code;
+    details;
+    constructor(message, status, code, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = "AionisHttpClientError";
+    }
+}
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractToolDecision(payload) {
+    if (!isRecord(payload))
+        return undefined;
+    const decision = isRecord(payload.decision) ? payload.decision : undefined;
+    const selection = isRecord(payload.selection) ? payload.selection : undefined;
+    const denied = Array.isArray(selection?.denied)
+        ? selection?.denied
+            .map((item) => (isRecord(item) && typeof item.name === "string" ? item.name : null))
+            .filter((item) => Boolean(item))
+        : [];
+    return {
+        decision_id: typeof decision?.decision_id === "string" ? decision.decision_id : undefined,
+        decision_uri: typeof decision?.decision_uri === "string" ? decision.decision_uri : undefined,
+        selected_tool: typeof decision?.selected_tool === "string"
+            ? decision.selected_tool
+            : typeof selection?.selected === "string"
+                ? selection.selected
+                : undefined,
+        denied_tools: denied,
+        explain: typeof payload.selection_summary === "string" ? payload.selection_summary : undefined,
+    };
+}
+export class AionisHttpLoopControlClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async post(path, body) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const headers = {
+            "content-type": "application/json",
+            "x-request-id": randomUUID(),
+            ...(this.options.defaultHeaders ?? {}),
+        };
+        if (this.options.apiKey)
+            headers["x-api-key"] = this.options.apiKey;
+        if (this.options.authBearer)
+            headers.authorization = `Bearer ${this.options.authBearer}`;
+        try {
+            const res = await fetch(joinUrl(this.options.baseUrl, path), {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            const payload = text ? JSON.parse(text) : {};
+            if (!res.ok) {
+                const message = isRecord(payload) && typeof payload.message === "string"
+                    ? payload.message
+                    : isRecord(payload) && typeof payload.error === "string"
+                        ? payload.error
+                        : `request failed with status ${res.status}`;
+                const code = isRecord(payload) && typeof payload.error === "string" ? payload.error : undefined;
+                throw new AionisHttpClientError(message, res.status, code, payload);
+            }
+            return payload;
+        }
+        catch (error) {
+            if (error instanceof AionisHttpClientError)
+                throw error;
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`aionis request timed out for ${path}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    withIdentity(scope, body) {
+        return {
+            tenant_id: this.options.tenantId,
+            actor: this.options.actor,
+            scope,
+            ...body,
+        };
+    }
+    async contextAssemble(args) {
+        const payload = await this.post("/v1/memory/context/assemble", this.withIdentity(args.scope, {
+            query_text: args.queryText,
+            context: args.context,
+            tool_candidates: args.toolCandidates,
+            include_rules: true,
+            return_layered_context: true,
+        }));
+        return {
+            layered_context: isRecord(payload.layered_context) ? { merged_text: typeof payload.layered_context.merged_text === "string" ? payload.layered_context.merged_text : undefined } : undefined,
+            tools: extractToolDecision(isRecord(payload.tools) ? payload.tools : payload),
+        };
+    }
+    async rulesEvaluate(args) {
+        return this.post("/v1/memory/rules/evaluate", this.withIdentity(args.scope, {
+            context: {
+                ...args.context,
+                tool_candidates: args.candidates,
+            },
+        }));
+    }
+    async toolsSelect(args) {
+        const payload = await this.post("/v1/memory/tools/select", this.withIdentity(args.scope, {
+            run_id: args.runId,
+            context: args.context,
+            candidates: args.candidates,
+            strict: true,
+        }));
+        return extractToolDecision(payload) ?? null;
+    }
+    async toolsDecision(args) {
+        return this.post("/v1/memory/tools/decision", this.withIdentity(args.scope, {
+            decision_id: args.decisionId,
+            decision_uri: args.decisionUri,
+            run_id: args.runId,
+        }));
+    }
+    async toolsFeedback(args) {
+        return this.post("/v1/memory/tools/feedback", this.withIdentity(args.scope, {
+            run_id: args.runId,
+            decision_id: args.decisionId,
+            decision_uri: args.decisionUri,
+            context: args.context,
+            candidates: args.candidates,
+            selected_tool: args.selectedTool,
+            outcome: args.outcome,
+            note: args.note,
+            input_text: args.inputText,
+        }));
+    }
+    async write(args) {
+        return this.post("/v1/memory/write", this.withIdentity(args.scope, {
+            input_text: args.inputText,
+            metadata: args.metadata,
+        }));
+    }
+    async handoffStore(args) {
+        return this.post("/v1/handoff/store", this.withIdentity(args.scope, {
+            anchor: args.anchor,
+            file_path: args.filePath,
+            repo_root: args.repoRoot,
+            symbol: args.symbol,
+            handoff_kind: args.handoffKind,
+            title: args.title,
+            summary: args.summary,
+            handoff_text: args.handoffText,
+            risk: args.risk,
+            acceptance_checks: args.acceptanceChecks,
+            tags: args.tags,
+            target_files: args.targetFiles,
+            next_action: args.nextAction,
+            must_change: args.mustChange,
+            must_remove: args.mustRemove,
+            must_keep: args.mustKeep,
+        }));
+    }
+    async replayPlaybookCandidate(args) {
+        const payload = await this.post("/v1/memory/replay/playbooks/candidate", this.withIdentity(args.scope, {
+            playbook_id: args.playbookId,
+            version: args.version,
+            deterministic_gate: args.deterministicGate,
+        }));
+        return {
+            playbook: isRecord(payload.playbook) ? {
+                playbook_id: typeof payload.playbook.playbook_id === "string" ? payload.playbook.playbook_id : undefined,
+                version: typeof payload.playbook.version === "number" ? payload.playbook.version : undefined,
+                status: typeof payload.playbook.status === "string" ? payload.playbook.status : undefined,
+                name: typeof payload.playbook.name === "string" ? payload.playbook.name : undefined,
+                uri: typeof payload.playbook.uri === "string" ? payload.playbook.uri : undefined,
+            } : undefined,
+            candidate: isRecord(payload.candidate) ? {
+                eligible_for_deterministic_replay: Boolean(payload.candidate.eligible_for_deterministic_replay),
+                recommended_mode: payload.candidate.recommended_mode === "strict" || payload.candidate.recommended_mode === "guided" || payload.candidate.recommended_mode === "simulate"
+                    ? payload.candidate.recommended_mode
+                    : undefined,
+                next_action: typeof payload.candidate.next_action === "string" ? payload.candidate.next_action : undefined,
+                mismatch_reasons: Array.isArray(payload.candidate.mismatch_reasons)
+                    ? payload.candidate.mismatch_reasons.filter((item) => typeof item === "string")
+                    : undefined,
+            } : undefined,
+            cost_signals: isRecord(payload.cost_signals) ? payload.cost_signals : undefined,
+        };
+    }
+    async replayPlaybookDispatch(args) {
+        return this.post("/v1/memory/replay/playbooks/dispatch", this.withIdentity(args.scope, {
+            playbook_id: args.playbookId,
+            version: args.version,
+            params: args.params,
+            mode: args.mode,
+            max_steps: args.maxSteps,
+            deterministic_gate: args.deterministicGate,
+        }));
+    }
+}
+export function createAionisHttpLoopControlClient(options) {
+    return new AionisHttpLoopControlClient(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types/openclaw.js";
+export * from "./types/aionis.js";
+export * from "./types/config.js";
+export * from "./adapter/state.js";
+export * from "./adapter/heuristics.js";
+export * from "./adapter/loop-control-adapter.js";
+export * from "./binding/openclaw-hook-binding.js";
+export * from "./client/aionis-http-client.js";
+export { default as openClawAionisAdapterPlugin } from "./plugin.js";
+export { attachToOpenClawHost as createOpenClawAionisAdapter } from "./binding/openclaw-hook-binding.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./types/openclaw.js";
+export * from "./types/aionis.js";
+export * from "./types/config.js";
+export * from "./adapter/state.js";
+export * from "./adapter/heuristics.js";
+export * from "./adapter/loop-control-adapter.js";
+export * from "./binding/openclaw-hook-binding.js";
+export * from "./client/aionis-http-client.js";
+export { default as openClawAionisAdapterPlugin } from "./plugin.js";
+export { attachToOpenClawHost as createOpenClawAionisAdapter } from "./binding/openclaw-hook-binding.js";

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+import type { OpenClawHostApi } from "./types/openclaw.js";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    register(api: OpenClawHostApi & {
+        pluginConfig?: Record<string, unknown>;
+        logger: {
+            info: (msg: string) => void;
+            warn: (msg: string) => void;
+        };
+    }): void;
+};
+export default plugin;

package/dist/plugin.js

@@ -0,0 +1,100 @@
+import { AionisLoopControlAdapter } from "./adapter/loop-control-adapter.js";
+import { attachToOpenClawHost } from "./binding/openclaw-hook-binding.js";
+import { createAionisHttpLoopControlClient } from "./client/aionis-http-client.js";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value, fallback = "") {
+    return typeof value === "string" ? value.trim() : fallback;
+}
+function asBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function asNumber(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function createScopeResolver(scopePrefix, scopeMode, fixedScope) {
+    return (ctx) => {
+        if (scopeMode === "fixed")
+            return fixedScope;
+        if (scopeMode === "session") {
+            const key = ctx.sessionKey ?? ctx.sessionId ?? "default";
+            return `${scopePrefix}:${key}`;
+        }
+        const workspace = ctx.workspaceDir?.trim();
+        if (!workspace)
+            return `${scopePrefix}:default`;
+        const normalized = workspace.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+        return `${scopePrefix}:${normalized || "workspace"}`;
+    };
+}
+function createReplayHintResolver(rawCfg) {
+    const playbookId = asString(rawCfg.replayPlaybookId);
+    if (!playbookId)
+        return undefined;
+    const mode = asString(rawCfg.replayMode);
+    const maxSteps = asNumber(rawCfg.replayMaxSteps, 0) || undefined;
+    const version = asNumber(rawCfg.replayVersion, 0) || undefined;
+    return () => ({
+        playbookId,
+        version,
+        mode: mode || undefined,
+        maxSteps,
+        params: { source: "openclaw-adapter.plugin" },
+        deterministicGate: {
+            enabled: true,
+            prefer_deterministic_execution: true,
+        },
+    });
+}
+function resolveConfig(rawCfg) {
+    const baseUrl = asString(rawCfg.baseUrl, process.env.AIONIS_BASE_URL ?? "http://127.0.0.1:3321");
+    const tenantId = asString(rawCfg.tenantId, process.env.AIONIS_TENANT_ID ?? "default");
+    const actor = asString(rawCfg.actor, process.env.AIONIS_ACTOR ?? "openclaw-aionis-adapter");
+    const scopePrefix = asString(rawCfg.scopePrefix, process.env.AIONIS_SCOPE_PREFIX ?? "openclaw");
+    const scopeMode = asString(rawCfg.scopeMode, "project") || "project";
+    const fixedScope = asString(rawCfg.scope, `${scopePrefix}:default`);
+    return {
+        baseUrl,
+        apiKey: asString(rawCfg.apiKey) || process.env.AIONIS_API_KEY || undefined,
+        authBearer: asString(rawCfg.authBearer) || process.env.AIONIS_AUTH_BEARER || undefined,
+        tenantId,
+        actor,
+        scopeResolver: createScopeResolver(scopePrefix, scopeMode, fixedScope),
+        replayHintResolver: createReplayHintResolver(rawCfg),
+        thresholds: {
+            enabled: asBoolean(rawCfg.enabled, true),
+            maxSteps: asNumber(rawCfg.maxSteps, 16),
+            maxSameToolStreak: asNumber(rawCfg.maxSameToolStreak, 4),
+            maxDuplicateObservationStreak: asNumber(rawCfg.maxDuplicateObservationStreak, 3),
+            maxNoProgressStreak: asNumber(rawCfg.maxNoProgressStreak, 3),
+            maxEstimatedTokenBurn: asNumber(rawCfg.maxEstimatedTokenBurn, 60000),
+            maxBroadTestInvocations: asNumber(rawCfg.maxBroadTestInvocations, 1),
+            maxBroadScanInvocations: asNumber(rawCfg.maxBroadScanInvocations, 1),
+        },
+        strictToolBlocking: asBoolean(rawCfg.strictToolBlocking, true),
+        replayDispatchEnabled: asBoolean(rawCfg.replayDispatchEnabled, true),
+        handoffFallbackEnabled: asBoolean(rawCfg.handoffFallbackEnabled, true),
+    };
+}
+const plugin = {
+    id: "openclaw-aionis-adapter",
+    name: "OpenClaw Aionis Adapter",
+    description: "Tool-loop control adapter for Aionis-backed policy, replay, handoff, and evidence capture.",
+    version: "0.1.0",
+    register(api) {
+        const rawCfg = asRecord(api.pluginConfig);
+        const resolved = resolveConfig(rawCfg);
+        const client = createAionisHttpLoopControlClient({
+            baseUrl: resolved.baseUrl,
+            tenantId: resolved.tenantId,
+            actor: resolved.actor,
+            apiKey: resolved.apiKey,
+            authBearer: resolved.authBearer,
+        });
+        const adapter = new AionisLoopControlAdapter(client, resolved);
+        attachToOpenClawHost(api, adapter);
+        api.logger.info(`openclaw-aionis-adapter: registered base=${resolved.baseUrl} tenant=${resolved.tenantId} replayDispatch=${resolved.replayDispatchEnabled} handoffFallback=${resolved.handoffFallbackEnabled}`);
+    },
+};
+export default plugin;

package/dist/types/aionis.d.ts

@@ -0,0 +1,129 @@
+export type AionisToolDecision = {
+    decision_id?: string;
+    decision_uri?: string;
+    selected_tool?: string | null;
+    selected?: string | null;
+    denied_tools?: string[];
+    explain?: string | null;
+    request_id?: string | null;
+};
+export type AionisReplayCandidate = {
+    playbook_id?: string;
+    score?: number;
+    reason?: string;
+    version?: number;
+    recommended_mode?: "simulate" | "strict" | "guided";
+};
+export type ReplayPlaybookHint = {
+    playbookId: string;
+    version?: number;
+    params?: Record<string, unknown>;
+    mode?: "simulate" | "strict" | "guided";
+    maxSteps?: number;
+    deterministicGate?: Record<string, unknown>;
+};
+export type AionisHttpClientOptions = {
+    baseUrl: string;
+    tenantId?: string;
+    actor?: string;
+    apiKey?: string;
+    authBearer?: string;
+    timeoutMs?: number;
+    defaultHeaders?: Record<string, string>;
+};
+export type AionisLoopControlClient = {
+    contextAssemble?: (args: {
+        scope: string;
+        queryText: string;
+        context: Record<string, unknown>;
+        toolCandidates?: string[];
+    }) => Promise<{
+        layered_context?: {
+            merged_text?: string;
+        };
+        tools?: AionisToolDecision;
+    } | null | undefined>;
+    rulesEvaluate?: (args: {
+        scope: string;
+        context: Record<string, unknown>;
+        candidates: string[];
+    }) => Promise<Record<string, unknown> | null | undefined>;
+    toolsSelect?: (args: {
+        scope: string;
+        runId: string;
+        context: Record<string, unknown>;
+        candidates: string[];
+    }) => Promise<AionisToolDecision | null | undefined>;
+    toolsDecision?: (args: {
+        scope: string;
+        decisionId?: string;
+        decisionUri?: string;
+        runId?: string;
+    }) => Promise<Record<string, unknown> | null | undefined>;
+    toolsFeedback?: (args: {
+        scope: string;
+        runId?: string;
+        decisionId?: string;
+        decisionUri?: string;
+        context: Record<string, unknown>;
+        candidates: string[];
+        selectedTool: string;
+        outcome: "positive" | "negative" | "neutral";
+        note?: string;
+        inputText: string;
+    }) => Promise<Record<string, unknown> | null | undefined>;
+    write?: (args: {
+        scope: string;
+        inputText: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<Record<string, unknown> | null | undefined>;
+    handoffStore?: (args: {
+        scope: string;
+        anchor: string;
+        filePath: string;
+        summary: string;
+        handoffText: string;
+        repoRoot?: string | null;
+        symbol?: string | null;
+        handoffKind?: "patch_handoff" | "review_handoff" | "task_handoff";
+        title?: string | null;
+        risk?: string | null;
+        acceptanceChecks?: string[];
+        tags?: string[];
+        targetFiles?: string[];
+        nextAction?: string | null;
+        mustChange?: string[];
+        mustRemove?: string[];
+        mustKeep?: string[];
+    }) => Promise<Record<string, unknown> | null | undefined>;
+    replayPlaybookCandidate?: (args: {
+        scope: string;
+        playbookId: string;
+        version?: number;
+        deterministicGate?: Record<string, unknown>;
+    }) => Promise<{
+        playbook?: {
+            playbook_id?: string;
+            version?: number;
+            status?: string;
+            name?: string | null;
+            uri?: string;
+        };
+        candidate?: {
+            eligible_for_deterministic_replay?: boolean;
+            recommended_mode?: "simulate" | "strict" | "guided";
+            next_action?: string;
+            mismatch_reasons?: string[];
+        };
+        cost_signals?: Record<string, unknown>;
+    } | null | undefined>;
+    replayPlaybookDispatch?: (args: {
+        scope: string;
+        playbookId: string;
+        version?: number;
+        params?: Record<string, unknown>;
+        mode?: "simulate" | "strict" | "guided";
+        maxSteps?: number;
+        deterministicGate?: Record<string, unknown>;
+    }) => Promise<Record<string, unknown> | null | undefined>;
+};

package/dist/types/aionis.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,36 @@
+import type { ReplayPlaybookHint } from "./aionis.js";
+export type LoopStopReasonCode = "max_steps_exceeded" | "same_tool_streak_exceeded" | "duplicate_observation_exceeded" | "no_progress_exceeded" | "budget_exceeded" | "policy_denied_only_path" | "replay_dispatch_selected" | "handoff_store_selected";
+export type AdapterThresholds = {
+    enabled: boolean;
+    maxSteps: number;
+    maxSameToolStreak: number;
+    maxDuplicateObservationStreak: number;
+    maxNoProgressStreak: number;
+    maxEstimatedTokenBurn: number;
+    maxBroadTestInvocations: number;
+    maxBroadScanInvocations: number;
+};
+export type AdapterConfig = {
+    tenantId: string;
+    actor: string;
+    scopeResolver: (ctx: {
+        agentId?: string;
+        sessionKey?: string;
+        sessionId?: string;
+        workspaceDir?: string;
+    }) => string;
+    replayHintResolver?: (ctx: {
+        agentId?: string;
+        sessionKey?: string;
+        sessionId?: string;
+        runId?: string;
+        workspaceDir?: string;
+        toolName?: string;
+        toolParams?: Record<string, unknown>;
+    }) => ReplayPlaybookHint | null | undefined;
+    thresholds: AdapterThresholds;
+    strictToolBlocking: boolean;
+    replayDispatchEnabled: boolean;
+    handoffFallbackEnabled: boolean;
+};
+export declare const DEFAULT_THRESHOLDS: AdapterThresholds;

package/dist/types/config.js

@@ -0,0 +1,10 @@
+export const DEFAULT_THRESHOLDS = {
+    enabled: true,
+    maxSteps: 16,
+    maxSameToolStreak: 4,
+    maxDuplicateObservationStreak: 3,
+    maxNoProgressStreak: 3,
+    maxEstimatedTokenBurn: 60000,
+    maxBroadTestInvocations: 1,
+    maxBroadScanInvocations: 1,
+};

package/dist/types/openclaw.d.ts

@@ -0,0 +1,81 @@
+export type OpenClawLogger = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export type OpenClawHookName = "before_agent_start" | "agent_end" | "before_tool_call" | "after_tool_call" | "tool_result_persist" | "before_message_write" | "session_start" | "session_end";
+export type OpenClawHostApi = {
+    logger: OpenClawLogger;
+    on?: (eventName: OpenClawHookName, handler: (event: any, ctx: any) => Promise<any> | any) => void;
+};
+export type OpenClawAgentRunContext = {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    trigger?: string;
+    channelId?: string;
+};
+export type OpenClawToolCallContext = OpenClawAgentRunContext & {
+    runId?: string;
+    toolName: string;
+    toolCallId?: string;
+};
+export type BeforeAgentStartEvent = {
+    prompt: string;
+    messages?: unknown[];
+};
+export type BeforeAgentStartResult = {
+    prependContext?: string;
+    systemPrompt?: string;
+    modelOverride?: string;
+    providerOverride?: string;
+};
+export type AgentEndEvent = {
+    messages: unknown[];
+    success: boolean;
+    error?: string;
+    durationMs?: number;
+};
+export type BeforeToolCallEvent = {
+    toolName: string;
+    params: Record<string, unknown>;
+    runId?: string;
+    toolCallId?: string;
+};
+export type BeforeToolCallResult = {
+    params?: Record<string, unknown>;
+    block?: boolean;
+    blockReason?: string;
+};
+export type AfterToolCallEvent = {
+    toolName: string;
+    params: Record<string, unknown>;
+    runId?: string;
+    toolCallId?: string;
+    result?: unknown;
+    error?: string;
+    durationMs?: number;
+};
+export type ToolResultPersistEvent = {
+    toolName?: string;
+    toolCallId?: string;
+    message: Record<string, unknown>;
+    isSynthetic?: boolean;
+};
+export type ToolResultPersistResult = {
+    message?: Record<string, unknown>;
+};
+export type BeforeMessageWriteEvent = {
+    message: Record<string, unknown>;
+    sessionKey?: string;
+    agentId?: string;
+};
+export type BeforeMessageWriteResult = {
+    block?: boolean;
+    message?: Record<string, unknown>;
+};
+export type SessionLifecycleEvent = {
+    sessionId: string;
+    sessionKey?: string;
+};

package/dist/types/openclaw.js

@@ -0,0 +1 @@
+export {};

package/examples/openclaw.json

@@ -0,0 +1,34 @@
+{
+  "agents": {
+    "defaults": {
+      "workspace": "/absolute/path/to/workspace",
+      "model": {
+        "primary": "google/gemini-3-flash-preview"
+      }
+    }
+  },
+  "plugins": {
+    "allow": ["openclaw-aionis-adapter"],
+    "entries": {
+      "openclaw-aionis-adapter": {
+        "enabled": true,
+        "config": {
+          "baseUrl": "http://127.0.0.1:3321",
+          "tenantId": "default",
+          "actor": "openclaw",
+          "scopeMode": "project",
+          "strictToolBlocking": true,
+          "replayDispatchEnabled": true,
+          "handoffFallbackEnabled": true,
+          "maxSteps": 8,
+          "maxSameToolStreak": 2,
+          "maxDuplicateObservationStreak": 2,
+          "maxNoProgressStreak": 2,
+          "maxEstimatedTokenBurn": 12000,
+          "maxBroadTestInvocations": 1,
+          "maxBroadScanInvocations": 1
+        }
+      }
+    }
+  }
+}