fix: correct MCP SSE launch, shebang ordering, and E2E helper scripts

- execution_mixin: replace non-existent FastMCP.create_app() with the
  repo's working low-level SSE transport pattern (connect_sse +
  handle_post_message), matching mcp/mcp_server.py; normalize base_path
  leading slash. Fixes AttributeError at MCP server startup.
- examples (36 files): move '# praisonai: skip=true' below the shebang so
  direct execution still works; directive stays within the runner's
  first-30-lines scan.
- failover_example: display real 'last_error' instead of unmodeled
  'failure_count' (which always printed 0).
- scripts/apply_e2e_batch3_*.py: make skip insertion shebang-aware, wire
  the previously-uncalled fix_mcp_env_examples(), and make the E2E report
  path a CLI argument (defaulting to the audit path).

Co-authored-by: Mervin Praison <[email protected]>

.github/actions/install-monorepo-packages/action.yml

@@ -1,5 +1,5 @@
 name: Install PraisonAI monorepo packages
-description: Install praisonai-agents, praisonai-code, praisonai-bot, praisonai-train, praisonai-browser, praisonai-mcp, praisonai-sandbox, praisonai-deploy, and praisonai wrapper from local paths (mirrors PyPI nine-package install order).
+description: Install praisonai-agents, praisonai-code, praisonai-bot, praisonai-train, praisonai-browser, praisonai-mcp, praisonai-sandbox, and praisonai wrapper from local paths (mirrors PyPI eight-package install order).
 
 inputs:
   repo-root:
@@ -40,7 +40,6 @@ runs:
         BROWSER_PKG="${BASE}src/praisonai-browser"
         MCP_PKG="${BASE}src/praisonai-mcp"
         SANDBOX_PKG="${BASE}src/praisonai-sandbox"
-        DEPLOY_PKG="${BASE}src/praisonai-deploy"
         WRAPPER_PKG="${BASE}src/praisonai"
 
         normalise_extras() {
@@ -70,8 +69,6 @@ runs:
           uv pip install --system -e .
           cd "$SANDBOX_PKG"
           uv pip install --system -e .
-          cd "$DEPLOY_PKG"
-          uv pip install --system -e .
           cd "$WRAPPER_PKG"
           uv pip install --system "${WRAPPER_SUFFIX}"
         else
@@ -89,8 +86,6 @@ runs:
           pip install -e .
           cd "$SANDBOX_PKG"
           pip install -e .
-          cd "$DEPLOY_PKG"
-          pip install -e .
           cd "$WRAPPER_PKG"
           pip install -e "${WRAPPER_SUFFIX}"
         fi

.github/scripts/release-gate-selftest.js

@@ -11,112 +11,47 @@ assert.ok(versions.currentCode);
 assert.ok(versions.currentWrapper);
 assert.ok(versions.targetCode);
 assert.ok(rg.PACKAGE_PATHS.includes('src/praisonai-code'));
-// Every released package must make the gate's path-change check eligible.
-for (const p of [
-  'src/praisonai', 'src/praisonai-agents', 'src/praisonai-code',
-  'src/praisonai-bot', 'src/praisonai-train', 'src/praisonai-browser',
-  'src/praisonai-mcp', 'src/praisonai-sandbox', 'src/praisonai-deploy',
-]) {
-  assert.ok(rg.PACKAGE_PATHS.includes(p), `PACKAGE_PATHS missing ${p}`);
-}
 
 const noonUtc = new Date('2026-07-08T12:00:00Z');
 const dayStart = rg.utcDayStart(noonUtc);
 assert.strictEqual(dayStart.toISOString(), '2026-07-08T00:00:00.000Z');
 
-function mockGithub({ runs = [], releases = [] } = {}) {
-  return {
-    rest: {
-      actions: {
-        listWorkflowRuns: async () => ({ data: { workflow_runs: runs } }),
-      },
-      repos: {
-        listReleases: async () => ({ data: releases }),
-      },
-    },
-  };
-}
-
 (async () => {
   assert.strictEqual(await rg.pypiVersionExists('praisonaiagents', '0.0.0'), false);
 
-  assert.strictEqual(rg.PATCH_RELEASE_INTERVAL_DAYS, 3);
-
-  // Dedupe is release-based: a v* release inside the window blocks…
-  const recentRelease = mockGithub({
-    releases: [{ tag_name: 'v4.6.159', published_at: '2026-07-08T09:00:00Z' }],
-  });
+  const mockGithub = {
+    rest: {
+      actions: {
+        listWorkflowRuns: async () => ({
+          data: {
+            workflow_runs: [
+              {
+                conclusion: 'success',
+                created_at: '2026-07-08T09:00:00Z',
+                status: 'completed',
+              },
+            ],
+          },
+        }),
+      },
+    },
+  };
   assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(recentRelease, 'o', 'r', noonUtc),
+    await rg.hasSuccessfulReleaseToday(mockGithub, 'o', 'r', noonUtc),
     true
   );
 
   const result = await rg.evaluateReleasePreflight(
-    recentRelease, 'o', 'r',
+    mockGithub, 'o', 'r',
     { headSha: 'abc', isCiTrigger: false, bump: 'patch', now: noonUtc },
     null
   );
-  assert.ok(result.reasons.some((r) => r.includes('every 3 days')));
-
-  // …an old release does not…
-  const oldRelease = mockGithub({
-    releases: [{ tag_name: 'v4.6.150', published_at: '2026-07-04T09:00:00Z' }],
-  });
-  assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(oldRelease, 'o', 'r', noonUtc),
-    false
-  );
-
-  // …and a dry-run "success" (workflow run, no release) does not consume the
-  // window: only real releases count.
-  const dryRunOnly = mockGithub({
-    runs: [{ conclusion: 'success', created_at: '2026-07-08T09:00:00Z', status: 'completed' }],
-    releases: [],
-  });
-  assert.strictEqual(
-    await rg.hasSuccessfulReleaseWithinDays(dryRunOnly, 'o', 'r', noonUtc),
-    false
-  );
-
-  // Active-run blocking: fresh waiting run blocks…
-  const freshWaiting = mockGithub({
-    runs: [{ status: 'waiting', conclusion: null, created_at: '2026-07-08T11:00:00Z', html_url: 'x' }],
-  });
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(freshWaiting, 'o', 'r', noonUtc, null),
-    true
-  );
-
-  // …a waiting run stuck longer than STALE_WAITING_HOURS no longer blocks…
-  const staleWaiting = mockGithub({
-    runs: [{ status: 'waiting', conclusion: null, created_at: '2026-07-08T01:00:00Z', html_url: 'x' }],
-  });
-  const warnings = [];
-  const fakeCore = { warning: (m) => warnings.push(m), info: () => {} };
-  assert.strictEqual(rg.STALE_WAITING_HOURS, 6);
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(staleWaiting, 'o', 'r', noonUtc, fakeCore),
-    false
-  );
-  assert.ok(warnings.length === 1 && warnings[0].includes('approve or cancel'));
-
-  // …but an in_progress run always blocks regardless of age.
-  const oldInProgress = mockGithub({
-    runs: [{ status: 'in_progress', conclusion: null, created_at: '2026-07-07T01:00:00Z', html_url: 'x' }],
-  });
-  assert.strictEqual(
-    await rg.hasActiveReleaseRun(oldInProgress, 'o', 'r', noonUtc, null),
-    true
-  );
+  assert.ok(result.reasons.some((r) => r.includes('already released today')));
 
   console.log('ok: bumpPatch');
   console.log('ok: readVersionsFromTree');
-  console.log('ok: PACKAGE_PATHS covers all 9 released packages');
   console.log('ok: pypiVersionExists missing version');
   console.log('ok: utcDayStart');
-  console.log('ok: release-based dedupe (recent blocks, old does not)');
-  console.log('ok: dry-run success does not consume the release window');
-  console.log('ok: 3-day dedupe blocks second release');
-  console.log('ok: fresh waiting run blocks; stale waiting run ignored with warning');
-  console.log('ok: in_progress always blocks');
+  console.log('ok: hasSuccessfulReleaseToday');
+  console.log('ok: daily dedupe blocks second release');
 })();

.github/scripts/release-gate.js

@@ -4,31 +4,10 @@
 
 const https = require('https');
 
-/** Every directory whose changes should make a release eligible — all nine
- * published packages (mirrors the skip_* inputs in pypi-release.yml). */
-const PACKAGE_PATHS = [
-  'src/praisonai',
-  'src/praisonai-agents',
-  'src/praisonai-code',
-  'src/praisonai-bot',
-  'src/praisonai-train',
-  'src/praisonai-browser',
-  'src/praisonai-mcp',
-  'src/praisonai-sandbox',
-  'src/praisonai-deploy',
-];
-/** Minimum days between successful patch auto-releases. */
-const PATCH_RELEASE_INTERVAL_DAYS = 3;
+const PACKAGE_PATHS = ['src/praisonai', 'src/praisonai-agents', 'src/praisonai-code'];
 const ACTIVE_RELEASE_STATUSES = new Set([
   'queued', 'in_progress', 'waiting', 'pending', 'requested',
 ]);
-/** A run stuck in `waiting` (environment approval) longer than this no longer
- * blocks the gate. GitHub only auto-fails unapproved deployments after 30
- * days, so without a cutoff one forgotten manual dispatch stalls all
- * auto-releases for up to a month. The run is warned about, never cancelled —
- * if later approved, the pypi-release concurrency group serializes it and its
- * pypi_exists checks no-op anything already published. */
-const STALE_WAITING_HOURS = 6;
 
 function bumpPatch(version) {
   const parts = version.split('.');
@@ -84,65 +63,36 @@ function pypiVersionExists(packageName, version) {
   });
 }
 
-async function hasActiveReleaseRun(github, owner, repo, now = new Date(), core = null) {
+async function hasActiveReleaseRun(github, owner, repo) {
   const runs = await github.rest.actions.listWorkflowRuns({
     owner,
     repo,
     workflow_id: 'pypi-release.yml',
     per_page: 20,
   });
-  const staleCutoff = now.getTime() - STALE_WAITING_HOURS * 60 * 60 * 1000;
-  return runs.data.workflow_runs.some((r) => {
-    if (!ACTIVE_RELEASE_STATUSES.has(r.status) || r.conclusion) return false;
-    if (r.status === 'waiting' && new Date(r.created_at).getTime() < staleCutoff) {
-      if (core) {
-        core.warning(
-          `Ignoring release run waiting >${STALE_WAITING_HOURS}h for environment approval: `
-          + `${r.html_url} — approve or cancel it. It no longer blocks auto-releases.`
-        );
-      }
-      return false;
-    }
-    return true;
-  });
+  return runs.data.workflow_runs.some(
+    (r) => ACTIVE_RELEASE_STATUSES.has(r.status) && !r.conclusion
+  );
 }
 
 function utcDayStart(now = new Date()) {
   return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
 }
 
-function releaseIntervalStart(now = new Date(), intervalDays = PATCH_RELEASE_INTERVAL_DAYS) {
-  return new Date(now.getTime() - intervalDays * 24 * 60 * 60 * 1000);
-}
-
-async function hasSuccessfulReleaseWithinDays(
-  github,
-  owner,
-  repo,
-  now = new Date(),
-  intervalDays = PATCH_RELEASE_INTERVAL_DAYS,
-) {
-  const windowStart = releaseIntervalStart(now, intervalDays);
-  // Dedupe on GitHub releases (v* tags) rather than run conclusions: a
-  // dry_run=true dispatch concludes 'success' without publishing anything and
-  // must not consume the release window. Only a real full release creates a
-  // v* GitHub release (bump_and_release.py's `gh release create`).
-  const releases = await github.rest.repos.listReleases({
+async function hasSuccessfulReleaseToday(github, owner, repo, now = new Date()) {
+  const dayStart = utcDayStart(now);
+  const runs = await github.rest.actions.listWorkflowRuns({
     owner,
     repo,
-    per_page: 10,
+    workflow_id: 'pypi-release.yml',
+    status: 'completed',
+    per_page: 30,
   });
-  return releases.data.some(
-    (r) => r.tag_name && r.tag_name.startsWith('v')
-      && new Date(r.published_at || r.created_at) >= windowStart
+  return runs.data.workflow_runs.some(
+    (r) => r.conclusion === 'success' && new Date(r.created_at) >= dayStart
   );
 }
 
-/** @deprecated Use hasSuccessfulReleaseWithinDays — kept for selftests. */
-async function hasSuccessfulReleaseToday(github, owner, repo, now = new Date()) {
-  return hasSuccessfulReleaseWithinDays(github, owner, repo, now, 1);
-}
-
 async function lastGreenCoreTestsSha(github, owner, repo) {
   const runs = await github.rest.actions.listWorkflowRuns({
     owner,
@@ -179,18 +129,15 @@ async function evaluateReleasePreflight(github, owner, repo, options, core) {
     return out;
   }
 
-  const referenceTime = options.now instanceof Date ? options.now : new Date();
-
-  if (await hasActiveReleaseRun(github, owner, repo, referenceTime, core)) {
+  if (await hasActiveReleaseRun(github, owner, repo)) {
     reasons.push('PyPI Release already in progress or awaiting approval');
     return out;
   }
 
-  if (await hasSuccessfulReleaseWithinDays(github, owner, repo, referenceTime)) {
-    reasons.push(
-      `already released within last ${PATCH_RELEASE_INTERVAL_DAYS} days; `
-      + `max one patch release every ${PATCH_RELEASE_INTERVAL_DAYS} days`
-    );
+  const referenceTime = options.now instanceof Date ? options.now : new Date();
+  if (await hasSuccessfulReleaseToday(github, owner, repo, referenceTime)) {
+    const day = referenceTime.toISOString().slice(0, 10);
+    reasons.push(`already released today (UTC ${day}); max one patch release per day`);
     return out;
   }
 
@@ -260,35 +207,8 @@ async function evaluateReleasePreflight(github, owner, repo, options, core) {
     out.headSha = evalSha;
     const greenSha = await lastGreenCoreTestsSha(github, owner, repo);
     if (greenSha !== evalSha) {
-      // Core Tests has path filters and honors [skip ci] (the release
-      // safety-net commit uses it), so the tip of main may legitimately have
-      // no Core Tests run of its own — e.g. a docs-only commit, or the
-      // "chore(release): … [skip ci]" commit right after a release. Accept a
-      // green ancestor when nothing under the released package paths changed
-      // after it; otherwise the cron path stalls until the next src/** push.
-      let greenAncestorOk = false;
-      if (greenSha && /^[0-9a-f]{40}$/.test(greenSha)) {
-        try {
-          execSync(`git merge-base --is-ancestor ${greenSha} ${evalSha}`);
-          const delta = execSync(
-            `git diff --name-only ${greenSha} ${evalSha} -- ${PACKAGE_PATHS.join(' ')}`,
-            { encoding: 'utf8' }
-          ).trim();
-          greenAncestorOk = delta === '';
-        } catch {
-          greenAncestorOk = false;
-        }
-      }
-      if (!greenAncestorOk) {
-        reasons.push(`CI not green on HEAD (last green: ${greenSha ? greenSha.slice(0, 7) : 'none'})`);
-        return out;
-      }
-      if (core) {
-        core.info(
-          `HEAD ${evalSha.slice(0, 7)} has no Core Tests run; accepting green ancestor `
-          + `${greenSha.slice(0, 7)} (no package-path changes since).`
-        );
-      }
+      reasons.push(`CI not green on HEAD (last green: ${greenSha ? greenSha.slice(0, 7) : 'none'})`);
+      return out;
     }
   }
 
@@ -302,11 +222,6 @@ module.exports = {
   bumpPatch,
   readVersionsFromTree,
   pypiVersionExists,
-  PATCH_RELEASE_INTERVAL_DAYS,
-  STALE_WAITING_HOURS,
-  releaseIntervalStart,
-  hasActiveReleaseRun,
-  hasSuccessfulReleaseWithinDays,
   hasSuccessfulReleaseToday,
   utcDayStart,
   evaluateReleasePreflight,

.github/workflows/nightly-release-gate.yml

@@ -1,12 +1,12 @@
 name: Nightly Release Gate
 
 # Preflight before PyPI Release (patch bump).
-# Triggers: Core Tests success on main (workflow_run) or cron every 3 days at 00:00 UTC.
-# Dedupe: max one successful patch release every 3 days (see release-gate.js).
+# Triggers: Core Tests success on main (workflow_run) or nightly cron at 00:00 UTC.
+# Dedupe: max one successful patch release per UTC day (see release-gate.js).
 
 on:
   schedule:
-    - cron: '0 0 */3 * *'
+    - cron: '0 0 * * *'
   workflow_dispatch:
     inputs:
       dry_run:
@@ -41,7 +41,7 @@ jobs:
         github.event.workflow_run.head_branch == 'main' &&
         github.event.workflow_run.event == 'push' &&
         !startsWith(github.event.workflow_run.head_commit.message, 'Release v') &&
-        !startsWith(github.event.workflow_run.head_commit.message, 'chore(release):')
+        !startsWith(github.event.workflow_run.head_commit.message, 'Bump praisonai')
       )
     runs-on: ubuntu-latest
     env:
@@ -69,10 +69,6 @@ jobs:
       - name: Fetch main and tags
         run: git fetch --tags origin main
 
-      # Guards the gate logic itself — no workflow ran these selftests before.
-      - name: Selftest release-gate script
-        run: node .github/scripts/release-gate-selftest.js
-
       - name: Preflight — path changes, CI SHA, dedupe
         id: preflight
         uses: actions/github-script@v7

.github/workflows/pypi-release.yml

@@ -61,29 +61,6 @@ on:
         required: false
         default: false
         type: boolean
-      skip_deploy:
-        description: 'Skip praisonai-deploy publish (recovery if already on PyPI)'
-        required: false
-        default: false
-        type: boolean
-      # NOTE: GitHub caps workflow_dispatch at 25 top-level inputs; this
-      # workflow has 23. Adding a 10th package (skip_* + *_version) hits 25.
-      only:
-        description: 'Release ONLY this package (forces skip on all others); all = no restriction'
-        required: false
-        default: all
-        type: choice
-        options:
-          - all
-          - agents
-          - code
-          - bot
-          - train
-          - browser
-          - mcp
-          - sandbox
-          - deploy
-          - wrapper
       agents_version:
         description: 'Override agents version (empty = auto bump from pyproject.toml)'
         required: false
@@ -124,11 +101,6 @@ on:
         required: false
         default: ''
         type: string
-      deploy_version:
-        description: 'Override praisonai-deploy version (empty = auto bump from pyproject.toml)'
-        required: false
-        default: ''
-        type: string
       source:
         description: 'Trigger source (audit trail)'
         required: false
@@ -162,35 +134,15 @@ jobs:
         'pypi-auto' || 'pypi'
       }}
     env:
-      # PyPI API token auth: username __token__, password = pypi-… token (see pypi.org/help/#invalid-auth)
-      UV_PUBLISH_USERNAME: __token__
-      UV_PUBLISH_PASSWORD: ${{ secrets.PYPI_TOKEN || secrets.PYPI_API_TOKEN }}
-      # GH_TOKEN is NOT set here: it is a GitHub App installation token minted in
-      # "Generate GitHub App token" and exported via $GITHUB_ENV, so releases are
-      # authored by praisonai-triage-agent[bot] rather than MervinPraison.
+      UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN || secrets.PYPI_API_TOKEN }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
     steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.CLAUDE_APP_ID }}
-          private-key: ${{ secrets.CLAUDE_APP_PRIVATE_KEY }}
-          owner: ${{ github.repository_owner }}
-          # Scope to this repo only. Without it the token is minted for every
-          # repository the owner has; this job never leaves PraisonAI (checkout,
-          # push to origin, and gh release create all target it).
-          repositories: ${{ github.event.repository.name }}
-
       - name: Checkout main
         uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
         with:
           ref: main
           fetch-depth: 0
-          token: ${{ steps.app-token.outputs.token }}
-          # Do not bake the token into .git/config: an http.extraheader would
-          # outrank the remote URL set in "Configure git" and pin this first
-          # (1h) token, defeating the refresh before the wrapper release.
-          persist-credentials: false
+          token: ${{ secrets.GH_TOKEN }}
 
       - name: Set up Python
         uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065  # v5
@@ -201,19 +153,10 @@ jobs:
         uses: astral-sh/setup-uv@38f3f104447c67c051c4a08e39b64a148898af3a  # v4
 
       - name: Configure git
-        env:
-          APP_TOKEN: ${{ steps.app-token.outputs.token }}
-          REPO: ${{ github.repository }}
         run: |
-          set -euo pipefail
-          git config user.name "praisonai-triage-agent[bot]"
-          git config user.email "272766704+praisonai-triage-agent[bot]@users.noreply.github.com"
-          # persist-credentials:false left the remote unauthenticated; push auth
-          # comes from the app token embedded here (masked in logs, and the
-          # token dies with the runner).
-          git remote set-url origin "https://x-access-token:${APP_TOKEN}@github.com/${REPO}.git"
-          echo "GH_TOKEN=${APP_TOKEN}" >> "$GITHUB_ENV"
-          GH_TOKEN="${APP_TOKEN}" gh auth setup-git
+          git config user.name "MervinPraison"
+          git config user.email "[email protected]"
+          gh auth setup-git
 
       - name: Release summary
         run: |
@@ -223,36 +166,6 @@ jobs:
           echo "Dry run: ${{ inputs.dry_run }}"
           echo "Environment: ${{ (inputs.source == 'ci' || inputs.source == 'nightly') && inputs.bump == 'patch' && 'pypi-auto' || 'pypi' }}"
 
-      # Single source of truth for which packages this run releases. `only`
-      # inverts into the skip flags here; everything downstream (version
-      # computation, PyPI detection, publish conditions) consumes these
-      # outputs, so a dedicated one-package release is one input instead of
-      # eight skip flags.
-      - name: Resolve effective skips
-        id: flags
-        env:
-          ONLY: ${{ inputs.only }}
-          SKIP_AGENTS: ${{ inputs.skip_agents }}
-          SKIP_CODE: ${{ inputs.skip_code }}
-          SKIP_BOT: ${{ inputs.skip_bot }}
-          SKIP_TRAIN: ${{ inputs.skip_train }}
-          SKIP_BROWSER: ${{ inputs.skip_browser }}
-          SKIP_MCP: ${{ inputs.skip_mcp }}
-          SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
-          SKIP_DEPLOY: ${{ inputs.skip_deploy }}
-          SKIP_WRAPPER: ${{ inputs.skip_wrapper }}
-        run: |
-          set -euo pipefail
-          for pkg in agents code bot train browser mcp sandbox deploy wrapper; do
-            var="SKIP_$(echo "$pkg" | tr '[:lower:]' '[:upper:]')"
-            skip="${!var}"
-            if [ -n "${ONLY}" ] && [ "${ONLY}" != "all" ] && [ "${ONLY}" != "$pkg" ]; then
-              skip=true
-            fi
-            echo "skip_${pkg}=${skip}" >> "$GITHUB_OUTPUT"
-            echo "skip_${pkg}=${skip}"
-          done
-
       - name: Compute release versions
         id: versions
         env:
@@ -265,15 +178,13 @@ jobs:
           BROWSER_OVERRIDE: ${{ inputs.browser_version }}
           MCP_OVERRIDE: ${{ inputs.mcp_version }}
           SANDBOX_OVERRIDE: ${{ inputs.sandbox_version }}
-          DEPLOY_OVERRIDE: ${{ inputs.deploy_version }}
-          SKIP_AGENTS: ${{ steps.flags.outputs.skip_agents }}
-          SKIP_CODE: ${{ steps.flags.outputs.skip_code }}
-          SKIP_BOT: ${{ steps.flags.outputs.skip_bot }}
-          SKIP_TRAIN: ${{ steps.flags.outputs.skip_train }}
-          SKIP_BROWSER: ${{ steps.flags.outputs.skip_browser }}
-          SKIP_MCP: ${{ steps.flags.outputs.skip_mcp }}
-          SKIP_SANDBOX: ${{ steps.flags.outputs.skip_sandbox }}
-          SKIP_DEPLOY: ${{ steps.flags.outputs.skip_deploy }}
+          SKIP_AGENTS: ${{ inputs.skip_agents }}
+          SKIP_CODE: ${{ inputs.skip_code }}
+          SKIP_BOT: ${{ inputs.skip_bot }}
+          SKIP_TRAIN: ${{ inputs.skip_train }}
+          SKIP_BROWSER: ${{ inputs.skip_browser }}
+          SKIP_MCP: ${{ inputs.skip_mcp }}
+          SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
         run: |
           python <<'PY'
           import os
@@ -310,7 +221,6 @@ jobs:
           browser_override = os.environ.get("BROWSER_OVERRIDE", "").strip()
           mcp_override = os.environ.get("MCP_OVERRIDE", "").strip()
           sandbox_override = os.environ.get("SANDBOX_OVERRIDE", "").strip()
-          deploy_override = os.environ.get("DEPLOY_OVERRIDE", "").strip()
           validate_version("agents_version", agents_override)
           validate_version("wrapper_version", wrapper_override)
           validate_version("code_version", code_override)
@@ -319,7 +229,6 @@ jobs:
           validate_version("browser_version", browser_override)
           validate_version("mcp_version", mcp_override)
           validate_version("sandbox_version", sandbox_override)
-          validate_version("deploy_version", deploy_override)
 
           agents_pyproject = root / "src/praisonai-agents/pyproject.toml"
           agents_content = agents_pyproject.read_text()
@@ -377,14 +286,6 @@ jobs:
               sys.exit(1)
           current_sandbox = sandbox_match.group(1)
 
-          deploy_pyproject = root / "src/praisonai-deploy/pyproject.toml"
-          deploy_content = deploy_pyproject.read_text()
-          deploy_match = re.search(r'^version\s*=\s*"([^"]+)"', deploy_content, re.MULTILINE)
-          if not deploy_match:
-              print("Could not read praisonai-deploy version from pyproject.toml", file=sys.stderr)
-              sys.exit(1)
-          current_deploy = deploy_match.group(1)
-
           wrapper_version_py = root / "src/praisonai/praisonai/version.py"
           wrapper_content = wrapper_version_py.read_text()
           wrapper_match = re.search(r'__version__ = "([^"]+)"', wrapper_content)
@@ -401,7 +302,6 @@ jobs:
               ("browser", current_browser),
               ("mcp", current_mcp),
               ("sandbox", current_sandbox),
-              ("deploy", current_deploy),
               ("wrapper", current_wrapper),
           ):
               if not SEMVER.match(value):
@@ -415,7 +315,6 @@ jobs:
           skip_browser = os.environ.get("SKIP_BROWSER", "false").lower() == "true"
           skip_mcp = os.environ.get("SKIP_MCP", "false").lower() == "true"
           skip_sandbox = os.environ.get("SKIP_SANDBOX", "false").lower() == "true"
-          skip_deploy = os.environ.get("SKIP_DEPLOY", "false").lower() == "true"
 
           if agents_override:
               agents_version = agents_override
@@ -466,13 +365,6 @@ jobs:
           else:
               sandbox_version = bump_version(current_sandbox)
 
-          if deploy_override:
-              deploy_version = deploy_override
-          elif skip_deploy:
-              deploy_version = current_deploy
-          else:
-              deploy_version = bump_version(current_deploy)
-
           if wrapper_override:
               wrapper_version = wrapper_override
           else:
@@ -487,7 +379,6 @@ jobs:
               fh.write(f"browser_version={browser_version}\n")
               fh.write(f"mcp_version={mcp_version}\n")
               fh.write(f"sandbox_version={sandbox_version}\n")
-              fh.write(f"deploy_version={deploy_version}\n")
               fh.write(f"wrapper_version={wrapper_version}\n")
               fh.write(f"current_agents={current_agents}\n")
               fh.write(f"current_code={current_code}\n")
@@ -496,7 +387,6 @@ jobs:
               fh.write(f"current_browser={current_browser}\n")
               fh.write(f"current_mcp={current_mcp}\n")
               fh.write(f"current_sandbox={current_sandbox}\n")
-              fh.write(f"current_deploy={current_deploy}\n")
               fh.write(f"current_wrapper={current_wrapper}\n")
 
           print(f"Agents:  {current_agents} -> {agents_version}")
@@ -506,7 +396,6 @@ jobs:
           print(f"Browser: {current_browser} -> {browser_version}")
           print(f"MCP:     {current_mcp} -> {mcp_version}")
           print(f"Sandbox: {current_sandbox} -> {sandbox_version}")
-          print(f"Deploy:  {current_deploy} -> {deploy_version}")
           print(f"Wrapper: {current_wrapper} -> {wrapper_version}")
           PY
 
@@ -521,17 +410,15 @@ jobs:
           BROWSER_VERSION: ${{ steps.versions.outputs.browser_version }}
           MCP_VERSION: ${{ steps.versions.outputs.mcp_version }}
           SANDBOX_VERSION: ${{ steps.versions.outputs.sandbox_version }}
-          DEPLOY_VERSION: ${{ steps.versions.outputs.deploy_version }}
           WRAPPER_VERSION: ${{ steps.versions.outputs.wrapper_version }}
-          INPUT_SKIP_AGENTS: ${{ steps.flags.outputs.skip_agents }}
-          INPUT_SKIP_CODE: ${{ steps.flags.outputs.skip_code }}
-          INPUT_SKIP_BOT: ${{ steps.flags.outputs.skip_bot }}
-          INPUT_SKIP_TRAIN: ${{ steps.flags.outputs.skip_train }}
-          INPUT_SKIP_BROWSER: ${{ steps.flags.outputs.skip_browser }}
-          INPUT_SKIP_MCP: ${{ steps.flags.outputs.skip_mcp }}
-          INPUT_SKIP_SANDBOX: ${{ steps.flags.outputs.skip_sandbox }}
-          INPUT_SKIP_DEPLOY: ${{ steps.flags.outputs.skip_deploy }}
-          INPUT_SKIP_WRAPPER: ${{ steps.flags.outputs.skip_wrapper }}
+          INPUT_SKIP_AGENTS: ${{ inputs.skip_agents }}
+          INPUT_SKIP_CODE: ${{ inputs.skip_code }}
+          INPUT_SKIP_BOT: ${{ inputs.skip_bot }}
+          INPUT_SKIP_TRAIN: ${{ inputs.skip_train }}
+          INPUT_SKIP_BROWSER: ${{ inputs.skip_browser }}
+          INPUT_SKIP_MCP: ${{ inputs.skip_mcp }}
+          INPUT_SKIP_SANDBOX: ${{ inputs.skip_sandbox }}
+          INPUT_SKIP_WRAPPER: ${{ inputs.skip_wrapper }}
         run: |
           set -euo pipefail
           skip_agents="${INPUT_SKIP_AGENTS}"
@@ -541,53 +428,30 @@ jobs:
           skip_browser="${INPUT_SKIP_BROWSER}"
           skip_mcp="${INPUT_SKIP_MCP}"
           skip_sandbox="${INPUT_SKIP_SANDBOX}"
-          skip_deploy="${INPUT_SKIP_DEPLOY}"
           skip_wrapper="${INPUT_SKIP_WRAPPER}"
-          # Returns 0 if published, 1 if definitively absent (404). Any other
-          # HTTP status (PyPI outage, 5xx, rate limit) FAILS the run: guessing
-          # "not published" would lead to a duplicate-upload failure midway
-          # through the release, which is strictly worse than stopping here
-          # before anything has been published.
-          pypi_published() { # $1=package $2=version
-            local code attempt
-            for attempt in 1 2 3; do
-              code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 30 \
-                "https://pypi.org/pypi/$1/$2/json" || echo "000")
-              case "$code" in
-                200) return 0 ;;
-                404) return 1 ;;
-                *) echo "PyPI check $1==$2 returned HTTP ${code} (attempt ${attempt}/3)"; sleep 5 ;;
-              esac
-            done
-            echo "❌ Cannot determine PyPI state for $1==$2; refusing to guess." >&2
-            exit 2
-          }
           if [ "$skip_agents" != "true" ]; then
-            pypi_published praisonaiagents "${AGENTS_VERSION}" && skip_agents=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonaiagents/${AGENTS_VERSION}/json" >/dev/null && skip_agents=true || true
           fi
           if [ "$skip_code" != "true" ]; then
-            pypi_published praisonai-code "${CODE_VERSION}" && skip_code=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-code/${CODE_VERSION}/json" >/dev/null && skip_code=true || true
           fi
           if [ "$skip_bot" != "true" ]; then
-            pypi_published praisonai-bot "${BOT_VERSION}" && skip_bot=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-bot/${BOT_VERSION}/json" >/dev/null && skip_bot=true || true
           fi
           if [ "$skip_train" != "true" ]; then
-            pypi_published praisonai-train "${TRAIN_VERSION}" && skip_train=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-train/${TRAIN_VERSION}/json" >/dev/null && skip_train=true || true
           fi
           if [ "$skip_browser" != "true" ]; then
-            pypi_published praisonai-browser "${BROWSER_VERSION}" && skip_browser=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-browser/${BROWSER_VERSION}/json" >/dev/null && skip_browser=true || true
           fi
           if [ "$skip_mcp" != "true" ]; then
-            pypi_published praisonai-mcp "${MCP_VERSION}" && skip_mcp=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-mcp/${MCP_VERSION}/json" >/dev/null && skip_mcp=true || true
           fi
           if [ "$skip_sandbox" != "true" ]; then
-            pypi_published praisonai-sandbox "${SANDBOX_VERSION}" && skip_sandbox=true || true
-          fi
-          if [ "$skip_deploy" != "true" ]; then
-            pypi_published praisonai-deploy "${DEPLOY_VERSION}" && skip_deploy=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai-sandbox/${SANDBOX_VERSION}/json" >/dev/null && skip_sandbox=true || true
           fi
           if [ "$skip_wrapper" != "true" ]; then
-            pypi_published praisonai "${WRAPPER_VERSION}" && skip_wrapper=true || true
+            curl -fsSL "https://pypi.org/pypi/praisonai/${WRAPPER_VERSION}/json" >/dev/null && skip_wrapper=true || true
           fi
           echo "skip_agents=${skip_agents}" >> "$GITHUB_OUTPUT"
           echo "skip_code=${skip_code}" >> "$GITHUB_OUTPUT"
@@ -596,9 +460,8 @@ jobs:
           echo "skip_browser=${skip_browser}" >> "$GITHUB_OUTPUT"
           echo "skip_mcp=${skip_mcp}" >> "$GITHUB_OUTPUT"
           echo "skip_sandbox=${skip_sandbox}" >> "$GITHUB_OUTPUT"
-          echo "skip_deploy=${skip_deploy}" >> "$GITHUB_OUTPUT"
           echo "skip_wrapper=${skip_wrapper}" >> "$GITHUB_OUTPUT"
-          if [ "$skip_agents" = "true" ] && [ "$skip_code" = "true" ] && [ "$skip_bot" = "true" ] && [ "$skip_train" = "true" ] && [ "$skip_browser" = "true" ] && [ "$skip_mcp" = "true" ] && [ "$skip_sandbox" = "true" ] && [ "$skip_deploy" = "true" ] && [ "$skip_wrapper" = "true" ]; then
+          if [ "$skip_agents" = "true" ] && [ "$skip_code" = "true" ] && [ "$skip_bot" = "true" ] && [ "$skip_train" = "true" ] && [ "$skip_browser" = "true" ] && [ "$skip_mcp" = "true" ] && [ "$skip_sandbox" = "true" ] && [ "$skip_wrapper" = "true" ]; then
             echo "All target versions already on PyPI — nothing to publish."
           fi
 
@@ -612,7 +475,6 @@ jobs:
           steps.pypi_exists.outputs.skip_browser == 'true' &&
           steps.pypi_exists.outputs.skip_mcp == 'true' &&
           steps.pypi_exists.outputs.skip_sandbox == 'true' &&
-          steps.pypi_exists.outputs.skip_deploy == 'true' &&
           steps.pypi_exists.outputs.skip_wrapper == 'true'
         run: echo "Idempotent skip — target versions already on PyPI."
 
@@ -620,43 +482,34 @@ jobs:
         if: inputs.dry_run
         run: |
           echo "Dry run — no publish, commit, or push."
-          echo "Only:            ${{ inputs.only }}"
           echo "Agents version:  ${{ steps.versions.outputs.agents_version }}"
           echo "Code version:    ${{ steps.versions.outputs.code_version }}"
           echo "Bot version:     ${{ steps.versions.outputs.bot_version }}"
           echo "Train version:   ${{ steps.versions.outputs.train_version }}"
           echo "Browser version: ${{ steps.versions.outputs.browser_version }}"
           echo "MCP version:     ${{ steps.versions.outputs.mcp_version }}"
-          echo "Sandbox version: ${{ steps.versions.outputs.sandbox_version }}"
-          echo "Deploy version:  ${{ steps.versions.outputs.deploy_version }}"
           echo "Wrapper version: ${{ steps.versions.outputs.wrapper_version }}"
           echo ""
-          if [ "${{ steps.flags.outputs.skip_agents }}" != "true" ]; then
+          if [ "${{ inputs.skip_agents }}" != "true" ]; then
             echo "Would publish praisonaiagents ${{ steps.versions.outputs.agents_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_code }}" != "true" ]; then
+          if [ "${{ inputs.skip_code }}" != "true" ]; then
             echo "Would publish praisonai-code ${{ steps.versions.outputs.code_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_bot }}" != "true" ]; then
+          if [ "${{ inputs.skip_bot }}" != "true" ]; then
             echo "Would publish praisonai-bot ${{ steps.versions.outputs.bot_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_train }}" != "true" ]; then
+          if [ "${{ inputs.skip_train }}" != "true" ]; then
             echo "Would publish praisonai-train ${{ steps.versions.outputs.train_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_browser }}" != "true" ]; then
+          if [ "${{ inputs.skip_browser }}" != "true" ]; then
             echo "Would publish praisonai-browser ${{ steps.versions.outputs.browser_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_mcp }}" != "true" ]; then
+          if [ "${{ inputs.skip_mcp }}" != "true" ]; then
             echo "Would publish praisonai-mcp ${{ steps.versions.outputs.mcp_version }}"
           fi
-          if [ "${{ steps.flags.outputs.skip_sandbox }}" != "true" ]; then
-            echo "Would publish praisonai-sandbox ${{ steps.versions.outputs.sandbox_version }}"
-          fi
-          if [ "${{ steps.flags.outputs.skip_deploy }}" != "true" ]; then
-            echo "Would publish praisonai-deploy ${{ steps.versions.outputs.deploy_version }}"
-          fi
-          if [ "${{ steps.flags.outputs.skip_wrapper }}" != "true" ]; then
-            echo "Would run bump_and_release.py ${{ steps.versions.outputs.wrapper_version }} --agents ${{ steps.versions.outputs.agents_version }} --code-pin ${{ steps.versions.outputs.code_version }} --bot-pin ${{ steps.versions.outputs.bot_version }} --train-pin ${{ steps.versions.outputs.train_version }} --browser-pin ${{ steps.versions.outputs.browser_version }} --mcp-pin ${{ steps.versions.outputs.mcp_version }} --sandbox-pin ${{ steps.versions.outputs.sandbox_version }} --deploy-pin ${{ steps.versions.outputs.deploy_version }}"
+          if [ "${{ inputs.skip_wrapper }}" != "true" ]; then
+            echo "Would run bump_and_release.py ${{ steps.versions.outputs.wrapper_version }} --agents ${{ steps.versions.outputs.agents_version }} --code-pin ${{ steps.versions.outputs.code_version }} --bot-pin ${{ steps.versions.outputs.bot_version }} --train-pin ${{ steps.versions.outputs.train_version }} --browser-pin ${{ steps.versions.outputs.browser_version }} --mcp-pin ${{ steps.versions.outputs.mcp_version }}"
             echo "Would uv publish praisonai ${{ steps.versions.outputs.wrapper_version }}"
           fi
 
@@ -684,9 +537,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonaiagents on PyPI
         if: >-
@@ -715,6 +566,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit agents version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_agents != true &&
+          steps.pypi_exists.outputs.skip_agents != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-agents/pyproject.toml src/praisonai-agents/uv.lock
+          git diff --cached --quiet && { echo "No agents files to commit"; exit 0; }
+          git commit -m "Bump praisonaiagents to ${{ steps.versions.outputs.agents_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-code
         if: >-
           inputs.dry_run != true &&
@@ -743,9 +607,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-code on PyPI
         if: >-
@@ -774,6 +636,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-code version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_code != true &&
+          steps.pypi_exists.outputs.skip_code != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-code/pyproject.toml src/praisonai-code/uv.lock src/praisonai-code/praisonai_code/__init__.py
+          git diff --cached --quiet && { echo "No code files to commit"; exit 0; }
+          git commit -m "Bump praisonai-code to ${{ steps.versions.outputs.code_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-bot
         if: >-
           inputs.dry_run != true &&
@@ -802,9 +677,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-bot on PyPI
         if: >-
@@ -833,6 +706,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-bot version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_bot != true &&
+          steps.pypi_exists.outputs.skip_bot != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-bot/pyproject.toml src/praisonai-bot/uv.lock src/praisonai-bot/praisonai_bot/_version.py
+          git diff --cached --quiet && { echo "No bot files to commit"; exit 0; }
+          git commit -m "Bump praisonai-bot to ${{ steps.versions.outputs.bot_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-train
         if: >-
           inputs.dry_run != true &&
@@ -861,9 +747,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-train on PyPI
         if: >-
@@ -892,6 +776,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-train version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_train != true &&
+          steps.pypi_exists.outputs.skip_train != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-train/pyproject.toml src/praisonai-train/uv.lock src/praisonai-train/praisonai_train/_version.py
+          git diff --cached --quiet && { echo "No train files to commit"; exit 0; }
+          git commit -m "Bump praisonai-train to ${{ steps.versions.outputs.train_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-browser
         if: >-
           inputs.dry_run != true &&
@@ -920,9 +817,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-browser on PyPI
         if: >-
@@ -951,6 +846,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-browser version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_browser != true &&
+          steps.pypi_exists.outputs.skip_browser != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-browser/pyproject.toml src/praisonai-browser/uv.lock src/praisonai-browser/praisonai_browser/_version.py
+          git diff --cached --quiet && { echo "No browser files to commit"; exit 0; }
+          git commit -m "Bump praisonai-browser to ${{ steps.versions.outputs.browser_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-mcp
         if: >-
           inputs.dry_run != true &&
@@ -979,9 +887,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-mcp on PyPI
         if: >-
@@ -1010,6 +916,19 @@ jobs:
             sleep "$INTERVAL"
           done
 
+      - name: Commit praisonai-mcp version bump
+        if: >-
+          inputs.dry_run != true &&
+          inputs.skip_mcp != true &&
+          steps.pypi_exists.outputs.skip_mcp != 'true'
+        run: |
+          set -euo pipefail
+          git add src/praisonai-mcp/pyproject.toml src/praisonai-mcp/uv.lock src/praisonai-mcp/praisonai_mcp/_version.py
+          git diff --cached --quiet && { echo "No mcp files to commit"; exit 0; }
+          git commit -m "Bump praisonai-mcp to ${{ steps.versions.outputs.mcp_version }}"
+          git pull --rebase origin main
+          git push origin main
+
       - name: Publish praisonai-sandbox
         if: >-
           inputs.dry_run != true &&
@@ -1038,9 +957,7 @@ jobs:
           rm -rf dist
           uv lock
           uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
+          uv publish
 
       - name: Wait for praisonai-sandbox on PyPI
         if: >-
@@ -1069,101 +986,20 @@ jobs:
             sleep "$INTERVAL"
           done
 
-      - name: Publish praisonai-deploy
+      - name: Commit praisonai-sandbox version bump
         if: >-
           inputs.dry_run != true &&
-          inputs.skip_deploy != true &&
-          steps.pypi_exists.outputs.skip_deploy != 'true'
-        working-directory: src/praisonai-deploy
-        env:
-          NEW_VERSION: ${{ steps.versions.outputs.deploy_version }}
-          CURRENT: ${{ steps.versions.outputs.current_deploy }}
+          inputs.skip_sandbox != true &&
+          steps.pypi_exists.outputs.skip_sandbox != 'true'
         run: |
           set -euo pipefail
-          python <<'PY'
-          import os
-          import re
-          from pathlib import Path
-          new = os.environ["NEW_VERSION"]
-          current = os.environ["CURRENT"]
-          pyproject = Path("pyproject.toml")
-          content = pyproject.read_text()
-          pyproject.write_text(content.replace(f'version = "{current}"', f'version = "{new}"', 1))
-          version_py = Path("praisonai_deploy/_version.py")
-          version_content = version_py.read_text()
-          version_py.write_text(re.sub(r'__version__ = "[^"]+"', f'__version__ = "{new}"', version_content, count=1))
-          PY
-
-          rm -rf dist
-          uv lock
-          uv build
-          # --check-url makes re-uploads idempotent: files already on PyPI are
-          # skipped instead of failing the publish (partial-upload recovery).
-          uv publish --check-url https://pypi.org/simple/
-
-      - name: Wait for praisonai-deploy on PyPI
-        if: >-
-          inputs.dry_run != true &&
-          inputs.skip_deploy != true &&
-          steps.pypi_exists.outputs.skip_deploy != 'true'
-        run: |
-          set -euo pipefail
-          PACKAGE="praisonai-deploy"
-          VERSION="${{ steps.versions.outputs.deploy_version }}"
-          MAX_WAIT=600
-          INTERVAL=30
-          START=$(date +%s)
-
-          while true; do
-            if curl -fsSL "https://pypi.org/pypi/${PACKAGE}/${VERSION}/json" >/dev/null; then
-              echo "✅ ${PACKAGE}==${VERSION} is available on PyPI"
-              exit 0
-            fi
-            ELAPSED=$(( $(date +%s) - START ))
-            if [ "$ELAPSED" -ge "$MAX_WAIT" ]; then
-              echo "❌ Timeout waiting for ${PACKAGE}==${VERSION} on PyPI"
-              exit 1
-            fi
-            echo "⏳ Waiting for ${PACKAGE}==${VERSION} ($(( MAX_WAIT - ELAPSED ))s remaining...)"
-            sleep "$INTERVAL"
-          done
-
-      # All per-package version bumps are still uncommitted at this point: the
-      # wrapper release below stages every one of them (bump_and_release.py's
-      # release_files list) into a SINGLE "Release v…" commit.
-
-      # App tokens expire after 1h and this job can exceed that (9 packages ×
-      # up to a 600s PyPI wait). Re-mint so the final commit/tag/push/release
-      # never runs on an expired token.
-      - name: Refresh GitHub App token
-        id: app-token-final
-        if: ${{ !cancelled() && inputs.dry_run != true }}
-        # A failed re-mint must not fail the release: the original token may
-        # still be valid, and the next step only swaps tokens on success.
-        continue-on-error: true
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.CLAUDE_APP_ID }}
-          private-key: ${{ secrets.CLAUDE_APP_PRIVATE_KEY }}
-          owner: ${{ github.repository_owner }}
-          repositories: ${{ github.event.repository.name }}
-
-      # Guarded on the refresh actually succeeding: if the re-mint failed
-      # (API blip), the ORIGINAL token — still wired into the remote URL and
-      # GH_TOKEN — may well be valid, and overwriting it with an empty string
-      # would turn a recoverable situation into a guaranteed auth failure.
-      - name: Use refreshed GitHub App token
-        if: ${{ !cancelled() && inputs.dry_run != true && steps.app-token-final.outcome == 'success' }}
-        env:
-          APP_TOKEN: ${{ steps.app-token-final.outputs.token }}
-          REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          git remote set-url origin "https://x-access-token:${APP_TOKEN}@github.com/${REPO}.git"
-          echo "GH_TOKEN=${APP_TOKEN}" >> "$GITHUB_ENV"
+          git add src/praisonai-sandbox/pyproject.toml src/praisonai-sandbox/uv.lock src/praisonai-sandbox/praisonai_sandbox/_version.py
+          git diff --cached --quiet && { echo "No sandbox files to commit"; exit 0; }
+          git commit -m "Bump praisonai-sandbox to ${{ steps.versions.outputs.sandbox_version }}"
+          git pull --rebase origin main
+          git push origin main
 
       - name: Bump and release wrapper
-        id: wrapper
         if: >-
           inputs.dry_run != true &&
           inputs.skip_wrapper != true &&
@@ -1178,8 +1014,7 @@ jobs:
             --browser-pin "${{ steps.versions.outputs.browser_version }}" \
             --mcp-pin "${{ steps.versions.outputs.mcp_version }}" \
             --sandbox-pin "${{ steps.versions.outputs.sandbox_version }}" \
-            --deploy-pin "${{ steps.versions.outputs.deploy_version }}" \
-            --wait --max-wait 600 --no-add-all --force
+            --wait --max-wait 600 --no-add-all
 
       - name: Publish praisonai wrapper to PyPI
         if: >-
@@ -1187,7 +1022,7 @@ jobs:
           inputs.skip_wrapper != true &&
           steps.pypi_exists.outputs.skip_wrapper != 'true'
         working-directory: src/praisonai
-        run: uv publish --check-url https://pypi.org/simple/
+        run: uv publish
 
       - name: Wait for praisonai on PyPI
         if: >-
@@ -1216,139 +1051,47 @@ jobs:
             sleep "$INTERVAL"
           done
 
-      # Actually probes PyPI — previously this step only echoed checkmarks
-      # from the input flags, so it "verified" publishes that never happened.
       - name: Verify PyPI versions
         if: inputs.dry_run != true
         run: |
           set -euo pipefail
-          verify() { # $1=pypi-name $2=version $3=effective-skip
-            if [ "$3" = "true" ]; then
-              echo "⏭️  $1 skipped"
-              return 0
-            fi
-            if curl -fsSL --max-time 30 "https://pypi.org/pypi/$1/$2/json" >/dev/null; then
-              echo "✅ $1==$2"
-            else
-              echo "❌ $1==$2 NOT found on PyPI"
-              exit 1
-            fi
-          }
-          verify praisonaiagents  "${{ steps.versions.outputs.agents_version }}"  "${{ steps.flags.outputs.skip_agents }}"
-          verify praisonai-code   "${{ steps.versions.outputs.code_version }}"    "${{ steps.flags.outputs.skip_code }}"
-          verify praisonai-bot    "${{ steps.versions.outputs.bot_version }}"     "${{ steps.flags.outputs.skip_bot }}"
-          verify praisonai-train  "${{ steps.versions.outputs.train_version }}"   "${{ steps.flags.outputs.skip_train }}"
-          verify praisonai-browser "${{ steps.versions.outputs.browser_version }}" "${{ steps.flags.outputs.skip_browser }}"
-          verify praisonai-mcp    "${{ steps.versions.outputs.mcp_version }}"     "${{ steps.flags.outputs.skip_mcp }}"
-          verify praisonai-sandbox "${{ steps.versions.outputs.sandbox_version }}" "${{ steps.flags.outputs.skip_sandbox }}"
-          verify praisonai-deploy "${{ steps.versions.outputs.deploy_version }}"  "${{ steps.flags.outputs.skip_deploy }}"
-          verify praisonai        "${{ steps.versions.outputs.wrapper_version }}" "${{ steps.flags.outputs.skip_wrapper }}"
+          AGENTS="${{ steps.versions.outputs.agents_version }}"
+          CODE="${{ steps.versions.outputs.code_version }}"
+          BOT="${{ steps.versions.outputs.bot_version }}"
+          TRAIN="${{ steps.versions.outputs.train_version }}"
+          BROWSER="${{ steps.versions.outputs.browser_version }}"
+          MCP="${{ steps.versions.outputs.mcp_version }}"
+          SANDBOX="${{ steps.versions.outputs.sandbox_version }}"
+          WRAPPER="${{ steps.versions.outputs.wrapper_version }}"
 
-      # Safety net. On a clean run the wrapper's "Release v…" commit already
-      # carries every bump and this is a no-op. It only fires when the single
-      # commit could not happen: a package publish failed midway (those versions
-      # are already live on PyPI, so the bumps must not be lost), skip_wrapper
-      # was set, or the wrapper itself failed.
-      - name: Persist any uncommitted version bumps
-        if: ${{ !cancelled() && inputs.dry_run != true }}
-        run: |
-          set -euo pipefail
-          # If the wrapper release did not complete, drop any uncommitted
-          # wrapper-side rewrites (version.py, Dockerfiles, pins): committing
-          # them would put a wrapper version on main that never reached PyPI,
-          # and the next auto-bump would skip past it forever. Committed
-          # changes are untouched (checkout only reverts the working tree),
-          # and if the wrapper was skipped these files were never modified.
-          if [ "${{ steps.wrapper.outcome }}" != "success" ]; then
-            git checkout -- \
-              src/praisonai/praisonai/version.py \
-              src/praisonai/pyproject.toml \
-              src/praisonai/uv.lock \
-              src/praisonai/README.md \
-              src/praisonai/praisonai.rb \
-              src/praisonai-deploy/praisonai_deploy/docker.py \
-              docker/ 2>/dev/null || true
+          if [ "${{ inputs.skip_agents }}" != "true" ]; then
+            echo "✅ praisonaiagents==${AGENTS}"
           fi
-          # -u = tracked modifications only; uv build output under dist/ is
-          # untracked and stays out of the commit.
-          git add -u
-          git diff --cached --quiet && { echo "Nothing left to commit"; exit 0; }
-          # Name the packages actually staged, so a single-package release
-          # (every other skip_* set) reads "bump praisonai-mcp" rather than a
-          # generic message. Falls back when nothing under src/ is staged.
-          PKGS="$(git diff --cached --name-only \
-            | sed -n 's#^src/\([^/]*\)/.*#\1#p' | sort -u | tr '\n' ' ' | sed 's/ *$//')"
-          if [ -n "$PKGS" ]; then
-            MSG="chore(release): bump ${PKGS} [skip ci]"
-          else
-            MSG="chore(release): persist version bumps [skip ci]"
-          fi
-          echo "Commit message: ${MSG}"
-          git commit -m "$MSG"
-          # This step fires exactly when the release went sideways — i.e. when
-          # main is most likely to have moved — so the rebase+push retries.
-          # Losing this commit deadlocks future auto-releases: the packages
-          # are on PyPI at N+1 while the repo says N, so every later run
-          # detects "already published" and skips both publish and bump.
-          for attempt in 1 2 3; do
-            git fetch origin main
-            if ! git rebase origin/main; then
-              git rebase --abort || true
-              # During rebase, "theirs" is the commit being replayed — the
-              # version bumps — so they win any conflict.
-              if ! git rebase -X theirs origin/main; then
-                git rebase --abort || true
-                echo "Rebase attempt ${attempt}/3 failed"
-                sleep 5
-                continue
-              fi
-            fi
-            if git push origin main; then
-              echo "Pushed version bumps (attempt ${attempt}/3)"
-              exit 0
-            fi
-            echo "Push attempt ${attempt}/3 rejected; retrying..."
-            sleep 5
-          done
-          echo "❌ Could not push version bumps after 3 attempts."
-          echo "   Repo is now BEHIND PyPI; commit the version files on main manually"
-          echo "   or future auto-releases will no-op ('already published')."
-          exit 1
 
-      # Dedicated releases (skip_wrapper) create no "Release v…" tag — the
-      # wrapper drives that — so tag each published package individually for
-      # provenance. Full releases keep their single v… tag unchanged.
-      - name: Tag dedicated package releases
-        if: >-
-          ${{ !cancelled() && inputs.dry_run != true &&
-              steps.flags.outputs.skip_wrapper == 'true' &&
-              steps.versions.outcome == 'success' }}
-        run: |
-          set -euo pipefail
-          tag_pkg() { # $1=effective-skip $2=pypi-name $3=version
-            if [ "$1" = "true" ]; then
-              return 0
-            fi
-            local tag="$2-v$3"
-            # Only tag what is confirmed on PyPI — a package whose publish
-            # failed must not get a tag claiming it shipped.
-            if ! curl -fsSL --max-time 30 "https://pypi.org/pypi/$2/$3/json" >/dev/null; then
-              echo "⏭️  $2==$3 not on PyPI; not tagging"
-              return 0
-            fi
-            if git rev-parse -q --verify "refs/tags/${tag}" >/dev/null; then
-              echo "tag ${tag} already exists"
-              return 0
-            fi
-            git tag "${tag}"
-            git push origin "refs/tags/${tag}"
-            echo "🏷️  ${tag}"
-          }
-          tag_pkg "${{ steps.flags.outputs.skip_agents }}"  praisonaiagents  "${{ steps.versions.outputs.agents_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_code }}"    praisonai-code   "${{ steps.versions.outputs.code_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_bot }}"     praisonai-bot    "${{ steps.versions.outputs.bot_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_train }}"   praisonai-train  "${{ steps.versions.outputs.train_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_browser }}" praisonai-browser "${{ steps.versions.outputs.browser_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_mcp }}"     praisonai-mcp    "${{ steps.versions.outputs.mcp_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_sandbox }}" praisonai-sandbox "${{ steps.versions.outputs.sandbox_version }}"
-          tag_pkg "${{ steps.flags.outputs.skip_deploy }}"  praisonai-deploy "${{ steps.versions.outputs.deploy_version }}"
+          if [ "${{ inputs.skip_code }}" != "true" ]; then
+            echo "✅ praisonai-code==${CODE}"
+          fi
+
+          if [ "${{ inputs.skip_bot }}" != "true" ]; then
+            echo "✅ praisonai-bot==${BOT}"
+          fi
+
+          if [ "${{ inputs.skip_train }}" != "true" ]; then
+            echo "✅ praisonai-train==${TRAIN}"
+          fi
+
+          if [ "${{ inputs.skip_browser }}" != "true" ]; then
+            echo "✅ praisonai-browser==${BROWSER}"
+          fi
+
+          if [ "${{ inputs.skip_mcp }}" != "true" ]; then
+            echo "✅ praisonai-mcp==${MCP}"
+          fi
+
+          if [ "${{ inputs.skip_sandbox }}" != "true" ]; then
+            echo "✅ praisonai-sandbox==${SANDBOX}"
+          fi
+
+          if [ "${{ inputs.skip_wrapper }}" != "true" ]; then
+            echo "✅ praisonai==${WRAPPER}"
+          fi

.github/workflows/test-core.yml

@@ -5,9 +5,6 @@ on:
     branches: [ main, develop ]
     paths:
       - 'src/**'
-      - 'src/praisonai-deploy/infra/**'
-      - 'src/praisonai-bot/infra/**'
-      - 'scripts/check_helm_charts.sh'
       - 'pyproject.toml'
       - '.github/workflows/test-core.yml'
       - '.github/actions/install-monorepo-packages/**'
@@ -15,9 +12,6 @@ on:
     branches: [ main, develop ]
     paths:
       - 'src/**'
-      - 'src/praisonai-deploy/infra/**'
-      - 'src/praisonai-bot/infra/**'
-      - 'scripts/check_helm_charts.sh'
       - 'pyproject.toml'
       - '.github/workflows/test-core.yml'
       - '.github/actions/install-monorepo-packages/**'
@@ -120,17 +114,11 @@ jobs:
             extra_ignore: ""
             pythonpath: >-
               ${{ github.workspace }}/src/praisonai-agents
-          - shard: deploy
-            workdir: src/praisonai-deploy
-            paths: >-
-              tests/
-            extra_ignore: ""
-            pythonpath: >-
-              ${{ github.workspace }}/src/praisonai-agents
           - shard: subdirs
             paths: >-
               tests/unit/scheduler/
               tests/unit/integrations/
+              tests/unit/deploy/
               tests/unit/mcp/
               tests/unit/knowledge/
               tests/unit/llm/
@@ -195,9 +183,6 @@ jobs:
         if [ "$WORKDIR" = "src/praisonai-sandbox" ]; then
           bash "$GITHUB_WORKSPACE/scripts/check_c13_sandbox_imports.sh"
         fi
-        if [ "$WORKDIR" = "src/praisonai-deploy" ]; then
-          bash "$GITHUB_WORKSPACE/scripts/check_c14_deploy_imports.sh"
-        fi
         if [ "$WORKDIR" = "src/praisonai-mcp" ]; then
           bash "$GITHUB_WORKSPACE/scripts/check_c12_mcp_imports.sh"
         fi
@@ -283,27 +268,9 @@ jobs:
           --ignore=tests/integration/test_tracker_complex_tasks.py \
           --ignore=tests/integration/test_serve_integration.py
 
-  helm-charts:
-    name: helm-charts
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        persist-credentials: false
-    - name: Setup Helm
-      uses: azure/setup-helm@v3
-      with:
-        version: v3.14.4
-    - name: Lint and template Helm charts
-      shell: bash
-      run: |
-        set -euo pipefail
-        bash "$GITHUB_WORKSPACE/scripts/check_helm_charts.sh"
-
   test-core:
     name: test-core
-    needs: [test-core-collect, test-core-unit, test-core-integration, helm-charts]
+    needs: [test-core-collect, test-core-unit, test-core-integration]
     if: always()
     runs-on: ubuntu-latest
     timeout-minutes: 5
@@ -315,9 +282,8 @@ jobs:
         collect='${{ needs.test-core-collect.result }}'
         unit='${{ needs.test-core-unit.result }}'
         integration='${{ needs.test-core-integration.result }}'
-        helm='${{ needs.helm-charts.result }}'
-        echo "collect=$collect unit=$unit integration=$integration helm=$helm"
-        if [ "$collect" != "success" ] || [ "$unit" != "success" ] || [ "$integration" != "success" ] || [ "$helm" != "success" ]; then
+        echo "collect=$collect unit=$unit integration=$integration"
+        if [ "$collect" != "success" ] || [ "$unit" != "success" ] || [ "$integration" != "success" ]; then
           echo "Core Tests failed"
           exit 1
         fi

.github/workflows/test-optimized.yml

@@ -86,7 +86,6 @@ jobs:
           tests/unit/test_c11_browser_backward_compat.py \
           tests/unit/test_c12_mcp_backward_compat.py \
           tests/unit/test_c13_sandbox_backward_compat.py \
-          tests/unit/test_c14_deploy_backward_compat.py \
           -q --tb=line --timeout=30 --maxfail=5
         python -m pytest tests/unit/cli/ \
           ../praisonai-bot/tests/unit/cli/test_onboard_command.py \
@@ -270,26 +269,10 @@ jobs:
         bash "$GITHUB_WORKSPACE/scripts/check_c13_sandbox_imports.sh"
         python -m pytest src/praisonai-sandbox/tests -q -m "not network"
 
-    - name: Standalone praisonai-deploy smoke (C14)
-      run: |
-        set -euo pipefail
-        python -m venv /tmp/praisonai-deploy-standalone
-        /tmp/praisonai-deploy-standalone/bin/pip install -q -e src/praisonai-agents -e src/praisonai-deploy
-        /tmp/praisonai-deploy-standalone/bin/python -c "
-        from praisonai_deploy._version import __version__ as pkg_version
-        import praisonai_deploy
-        assert praisonai_deploy.__version__ == pkg_version
-        assert 'main' not in __import__('sys').modules
-        print('deploy standalone ok', praisonai_deploy.__version__)
-        "
-        /tmp/praisonai-deploy-standalone/bin/praisonai-deploy --help
-        bash "$GITHUB_WORKSPACE/scripts/check_c14_deploy_imports.sh"
-        python -m pytest src/praisonai-deploy/tests -q -m "not network"
-
     - name: Audit hybrid module imports (C8 full stack)
       run: |
         set -euo pipefail
-        pip install -q -e src/praisonai-agents -e src/praisonai-code -e src/praisonai-bot -e src/praisonai-train -e src/praisonai-browser -e src/praisonai-mcp -e src/praisonai-sandbox -e src/praisonai-deploy -e src/praisonai
+        pip install -q -e src/praisonai-agents -e src/praisonai-code -e src/praisonai-bot -e src/praisonai-train -e src/praisonai-browser -e src/praisonai-mcp -e src/praisonai-sandbox -e src/praisonai
         python scripts/audit_hybrid_modules.py
     
     - name: Smoke Test Summary
@@ -799,9 +782,6 @@ jobs:
           tests/unit/test_decorator_simple.py
           tests/unit/test_db_adapter_tracing_init.py
           ../praisonai-bot/tests/unit/test_bot_wiring.py
-          ../praisonai-bot/tests/unit/bots/test_enable_shell.py
-          ../praisonai-bot/tests/unit/gateway/test_preflight.py
-          ../praisonai-bot/tests/unit/gateway/test_gateway_doctor.py
           ../praisonai-bot/tests/unit/test_bot_history.py
           ../praisonai-bot/tests/unit/test_bot_fixes.py
           tests/unit/test_auto_lazy_loading.py

.gitignore

@@ -12,7 +12,6 @@ assets
 .DS_Store
 .pytest_cache
 praisonAI.egg-info
-src/*/build/
 flagged
 test.yaml
 db
@@ -25,8 +24,6 @@ output
 !src/praisonai-agents/praisonaiagents/output/
 !src/praisonai-code/praisonai_code/cli/output/
 !src/praisonai-bot/praisonai_bot/cli/output/
-!src/praisonai-ts/src/db/
-!src/praisonai-ts/src/cli/output/
 
 .files
 threads.db

AGENTS.md

@@ -7,9 +7,9 @@ You are working on the PraisonAI project.
 - Be concise and helpful in responses  
 - Test implementation thoroughly
 - Ensure backward compatibility with existing APIs
-- Follow protocol-driven design across the nine packages: core protocols in `praisonaiagents/`, agentic terminal CLI in `praisonai-code/`, bots/gateway in `praisonai-bot/`, LLM fine-tuning + agent training in `praisonai-train/`, browser automation in `praisonai-browser/`, MCP server host in `praisonai-mcp/`, sandbox backends in `praisonai-sandbox/`, deployment in `praisonai-deploy/`, integrations/serve/dashboard in the `praisonai/` wrapper
+- Follow protocol-driven design across the eight packages: core protocols in `praisonaiagents/`, agentic terminal CLI in `praisonai-code/`, bots/gateway in `praisonai-bot/`, LLM fine-tuning + agent training in `praisonai-train/`, browser automation in `praisonai-browser/`, MCP server host in `praisonai-mcp/`, sandbox backends in `praisonai-sandbox/`, integrations/serve/dashboard in the `praisonai/` wrapper
 - Preserve old `praisonai.*` import paths via shims when moving code between packages (see §2.3 in `src/praisonai-agents/AGENTS.md`; shim helpers in `src/praisonai/praisonai/cli/_shim.py`)
 - Package boundaries and dependency rules: `ARCHITECTURE.md` §2 (Tier 2 packages must never PyPI-depend on the wrapper; cross-tier access goes through lazy `_*_bridge` modules)
-- Boundary manifests: `src/praisonai/tests/PRAISONAI_BOT_MANIFEST.md` (C9), `src/praisonai/tests/PRAISONAI_TRAIN_MANIFEST.md` (C10), `src/praisonai/tests/PRAISONAI_BROWSER_MANIFEST.md` (C11), `src/praisonai/tests/PRAISONAI_MCP_MANIFEST.md` (C12), `src/praisonai/tests/PRAISONAI_SANDBOX_MANIFEST.md` (C13), `src/praisonai/tests/PRAISONAI_DEPLOY_MANIFEST.md` (C14)
+- Boundary manifests: `src/praisonai/tests/PRAISONAI_BOT_MANIFEST.md` (C9), `src/praisonai/tests/PRAISONAI_TRAIN_MANIFEST.md` (C10), `src/praisonai/tests/PRAISONAI_BROWSER_MANIFEST.md` (C11), `src/praisonai/tests/PRAISONAI_MCP_MANIFEST.md` (C12), `src/praisonai/tests/PRAISONAI_SANDBOX_MANIFEST.md` (C13)
 - When reviewing a PR or an issue, evaluate whether the change addresses a framework concern or a user goal, and design its surface (params, naming, defaults) accordingly
 - The aim of this package is to stay **lightweight and powerful**. Do a critical review at each stage — when triaging an issue, when planning a fix, and when reviewing/implementing a PR. Reject scope creep for the sake of adding features: if a capability already exists (e.g. via existing Agent params like `instructions`/`backstory`/`tools`/`hooks`/`memory`), prefer it over a new API surface. A change must genuinely strengthen the SDK (simpler, more robust, more user-friendly) — do not add knobs, params, modules, or exports that have no live consumer or that merely duplicate existing behaviour.

ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # PraisonAI Architecture
 
-> **Last updated:** 2026-07-31 (C14 — nine-package tiered model)
+> **Last updated:** 2026-07-17 (C13 — eight-package tiered model)
 >
 > Strategic architecture document for PraisonAI — a multi-agent AI framework.
 > Covers **Python tiered package model (C7.1 + C9 + C10)**, system design, runtime
@@ -11,7 +11,7 @@
 ## Table of Contents
 
 1. [Executive Summary](#1-executive-summary)
-2. [Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13 + C14)](#2-python-tiered-package-model-c71--c9--c10--c11--c12--c13--c14)
+2. [Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13)](#2-python-tiered-package-model-c71--c9--c10--c11--c12--c13)
 3. [System Overview](#3-system-overview)
 4. [Layered Architecture](#4-layered-architecture)
 5. [Core Data Contracts](#5-core-data-contracts)
@@ -51,18 +51,17 @@ Orchestration + Observability** core to unlock adoption and trust:
 
 ---
 
-## 2. Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13 + C14)
+## 2. Python Tiered Package Model (C7.1 + C9 + C10 + C11 + C12 + C13)
 
-**Release:** v4.6.110+ · `praisonaiagents` · `praisonai-code` · `praisonai-bot` · `praisonai-train` · `praisonai-browser` · `praisonai-mcp` · `praisonai-sandbox` · `praisonai-deploy` · `praisonai`
+**Release:** v4.6.110+ · `praisonaiagents` · `praisonai-code` · `praisonai-bot` · `praisonai-train` · `praisonai-browser` · `praisonai-mcp` · `praisonai-sandbox` · `praisonai`
 
-The Python monorepo publishes nine packages in three tiers with strict dependency
+The Python monorepo publishes eight packages in three tiers with strict dependency
 direction. C7 delivered a standalone agentic hot path; C7.1 formalised
 code/wrapper ownership; C9 extracted bots, gateway, and channel CLI into
 `praisonai-bot`; C10 extracted LLM fine-tuning and agent training into
 `praisonai-train`; C11 extracted browser automation into `praisonai-browser`;
 C12 extracted the heavy MCP host into `praisonai-mcp`.
 C13 extracted sandbox backends into `praisonai-sandbox`.
-C14 extracted deployment (API, Docker, cloud) into `praisonai-deploy`.
 
 ```mermaid
 flowchart TB
@@ -70,14 +69,13 @@ flowchart TB
     Agents["praisonaiagents<br/>Agent, tools, memory, hooks, protocols"]
   end
 
-  subgraph tier2 [Tier 2 — Terminal + Bot + Train + Browser + MCP + Sandbox + Deploy]
+  subgraph tier2 [Tier 2 — Terminal + Bot + Train + Browser + MCP + Sandbox]
     Code["praisonai-code<br/>run, chat, code, Typer, runtime, LLM"]
     Bot["praisonai-bot<br/>bots, gateway, channel CLI, OS daemon"]
     Train["praisonai-train<br/>LLM fine-tuning, agent training"]
     Browser["praisonai-browser<br/>extension bridge, CDP, Playwright"]
     MCP["praisonai-mcp<br/>MCP server host, auth, capability adapters"]
     Sandbox["praisonai-sandbox<br/>Docker, E2B, Modal, Sandlock backends"]
-    Deploy["praisonai-deploy<br/>API, Docker, AWS/Azure/GCP deploy"]
   end
 
   subgraph tier3 [Tier 3 — Wrapper]
@@ -90,53 +88,36 @@ flowchart TB
   Agents --> Browser
   Agents --> MCP
   Agents --> Sandbox
-  Agents --> Deploy
   Agents --> Wrapper
   Code -.->|"lazy _bot_bridge"| Bot
   Code -.->|"lazy _train_bridge"| Train
   Code -.->|"lazy _browser_bridge"| Browser
   Code -.->|"lazy _mcp_bridge"| MCP
   Code -.->|"lazy _sandbox_bridge"| Sandbox
-  Code -.->|"lazy _deploy_bridge"| Deploy
   Code -.->|"lazy _wrapper_bridge"| Wrapper
   Bot -.->|"lazy _code_bridge / _wrapper_bridge"| Code
   Bot -.->|"lazy _wrapper_bridge"| Wrapper
   Train -.->|"lazy _code_bridge / _wrapper_bridge"| Code
 ```
 
-**PyPI publish order:** `praisonaiagents` → `praisonai-code` + `praisonai-bot` + `praisonai-train` + `praisonai-browser` + `praisonai-mcp` + `praisonai-sandbox` + `praisonai-deploy` → `praisonai`
+**PyPI publish order:** `praisonaiagents` → `praisonai-code` + `praisonai-bot` + `praisonai-train` + `praisonai-browser` + `praisonai-mcp` + `praisonai-sandbox` → `praisonai`
 
 **Backward compatibility:** `praisonai.bots`, `praisonai.gateway`, `praisonai.train`,
-`praisonai.browser`, `praisonai.mcp_server`, `praisonai.sandbox`, `praisonai.deploy`, and related CLI paths remain as
+`praisonai.browser`, `praisonai.mcp_server`, `praisonai.sandbox`, and related CLI paths remain as
 `alias_package` shims to `praisonai_bot.*` / `praisonai_train.*` /
-`praisonai_browser.*` / `praisonai_mcp.*` / `praisonai_sandbox.*` / `praisonai_deploy.*`.
+`praisonai_browser.*` / `praisonai_mcp.*` / `praisonai_sandbox.*`.
 
 | Tier | Package | Owns | Must not depend on |
 |------|---------|------|-------------------|
-| 1 | `src/praisonai-agents/` | Agent, tools, memory, hooks, `frameworks/` protocols, sandbox protocols | `praisonai`, `praisonai-code`, `praisonai-bot`, `praisonai-train`, `praisonai-browser`, `praisonai-mcp`, `praisonai-sandbox`, `praisonai-deploy` |
+| 1 | `src/praisonai-agents/` | Agent, tools, memory, hooks, `frameworks/` protocols, sandbox protocols | `praisonai`, `praisonai-code`, `praisonai-bot`, `praisonai-train`, `praisonai-browser`, `praisonai-mcp`, `praisonai-sandbox` |
 | 2a | `src/praisonai-code/` | `run`/`chat`/`code`, Typer, runtime, LLM, tool resolution | **`praisonai` as a PyPI dependency** (optional lazy imports via `_wrapper_bridge` only) |
 | 2b | `src/praisonai-bot/` | Bots, gateway, channel CLI, OS daemon, gateway scheduler tick | **`praisonai` as a PyPI dependency** (optional lazy `_wrapper_bridge` for jobs/UI) |
 | 2c | `src/praisonai-train/` | LLM fine-tuning (Unsloth), agent training, `train` CLI, conda env setup | **`praisonai` as a PyPI dependency** (lazy `_code_bridge` for legacy dispatch) |
 | 2d | `src/praisonai-browser/` | Extension bridge, CDP/hybrid automation, `browser` CLI | **`praisonai` as a PyPI dependency** (none required; depends on `praisonaiagents` only) |
 | 2e | `src/praisonai-mcp/` | MCP server host, auth, transports, `mcp` CLI | **`praisonai` as a PyPI dependency** (lazy `_wrapper_bridge` for full capability registry) |
 | 2f | `src/praisonai-sandbox/` | Sandbox backends (Docker, E2B, Modal, Sandlock, SSH), `SandboxRegistry` | **`praisonai` as a PyPI dependency** (lazy `_code_bridge` for `PluginRegistry`) |
-| 2g | `src/praisonai-deploy/` | Deploy API/Docker/cloud, `deploy` CLI, scheduler integration | **`praisonai` as a PyPI dependency** (lazy `_plugin_registry` via `_code_bridge`) |
 | 3 | `src/praisonai/` | `framework_adapters/`, serve, dashboard, async jobs API | — |
 
-### Repo infra (not PyPI)
-
-Deployment packaging that stays in the git checkout, not in any tier-2 wheel:
-
-| Path | Runtime owner | Orchestration |
-|------|---------------|---------------|
-| `src/praisonai-bot/infra/helm/praisonai-gateway/` | `praisonai-bot` (gateway) | C14 `deploy helm` wrapper |
-| `src/praisonai-deploy/infra/helm/praisonai-agents-api/` | Generated API from C14 | C14 cross-link |
-| `src/praisonai-deploy/infra/compose/agents-stack/` | Docker Compose | `praisonai deploy compose up/down` |
-| `src/praisonai-deploy/infra/starters/` | Starter scaffolds | `praisonai deploy create --template` |
-| `docker/` | Mixed (wrapper/bot dev stacks) | Not C14 — see bot manifest for `docker/bots/` |
-
-Same boundary as C14: Helm/K8s manifests are **repo infra**, not `pip install praisonai-deploy` content.
-
 **Config kernel:** Phase 0 `praisonai/common/` was skipped; shared config lives in
 `praisonai_code/cli/configuration/` and is reached by the bot tier via lazy
 `_code_bridge` (see `src/praisonai/tests/CONFIG_KERNEL.md`).

README.md

@@ -41,6 +41,10 @@ curl -fsSL https://praison.ai/install.sh | bash
   <img src=".github/images/dashboard.png" alt="PraisonAI Dashboard" width="800" />
 </p>
 
+<p align="center">
+  <img src=".github/images/agentflow.gif" alt="PraisonAI AgentFlow" width="800" />
+</p>
+
 ```
  ██████╗ ██████╗  █████╗ ██╗███████╗ ██████╗ ███╗   ██╗     █████╗ ██╗
  ██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██╔═══██╗████╗  ██║    ██╔══██╗██║
@@ -52,6 +56,12 @@ curl -fsSL https://praison.ai/install.sh | bash
  pip install praisonai
 ```
 
+<p align="center">
+  <img src=".github/images/latest_ai_news_and_crawl_each_url_to_find_info.gif" alt="PraisonAI command execution" width="800" />
+</p>
+
+\* `export TAVILY_API_KEY=xxxxx`
+
 <div align="center">
   <a href="https://docs.praison.ai">
     <p align="center">
@@ -96,170 +106,6 @@ agent.start("Analyze the top 3 tech trends of 2026 and format as a markdown tabl
 
 ---
 
-## 🧬 The Five-Layer Agent Stack
-
-Most frameworks hand you one or two layers and leave the rest as homework. PraisonAI covers **all five** — plus the outer layer that decides *where* your agent actually runs.
-
-Each layer wraps the one inside it. When an agent misbehaves, the layer tells you where to look.
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│ ⬡ MANAGED AGENTS — Where does it actually run?                  │
-│ ┌─────────────────────────────────────────────────────────────┐ │
-│ │ 5 · GRAPH — Who runs when, and who checks whom?             │ │
-│ │ ┌─────────────────────────────────────────────────────────┐ │ │
-│ │ │ 4 · LOOP — When do we stop?                             │ │ │
-│ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │
-│ │ │ │ 3 · HARNESS — Can it act, and be checked?           │ │ │ │
-│ │ │ │ ┌─────────────────────────────────────────────────┐ │ │ │ │
-│ │ │ │ │ 2 · CONTEXT — Is the right thing in the window? │ │ │ │ │
-│ │ │ │ │ ┌─────────────────────────────────────────────┐ │ │ │ │ │
-│ │ │ │ │ │ 1 · PROMPT — Did I say it clearly?          │ │ │ │ │ │
-│ │ │ │ │ └─────────────────────────────────────────────┘ │ │ │ │ │
-│ │ │ │ └─────────────────────────────────────────────────┘ │ │ │ │
-│ │ │ └─────────────────────────────────────────────────────┘ │ │ │
-│ │ └─────────────────────────────────────────────────────────┘ │ │
-│ └─────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-| Layer | The question it answers | PraisonAI |
-|:--|:--|:--|
-| **1 · Prompt** | Did I say it clearly? | `instructions=`, `role`/`goal`/`backstory`, `output=`, `templates=` |
-| **2 · Context** | Is the right thing in the window? | `memory=`, `knowledge=`, `context=`, handoff `ContextPolicy` |
-| **3 · Harness** | Can it act, and be checked? | `tools=`, `MCP()`, `guardrails=`, `approval=`, `hooks=`, `sandbox=` |
-| **4 · Loop** | When do we stop? | `execution=ExecutionConfig(...)`, `reflection=`, `autonomy=`, doom-loop detection |
-| **5 · Graph** | Who runs when, and who checks whom? | `AgentFlow`, `route()`, `parallel()`, `loop()`, `repeat()` |
-| **⬡ Managed** | *Where does it actually run?* | `backend=ManagedAgent(compute="e2b")` — remote sandbox, or a fully hosted loop |
-
-### Layer 1 · Prompt — *Did I say it clearly?*
-
-Role, instructions, examples, output format.
-
-```python
-from praisonaiagents import Agent
-
-agent = Agent(
-    role="Senior Data Analyst",
-    goal="Turn raw numbers into decisions",
-    output="verbose",              # markdown-formatted output
-)
-agent.start("Summarise Q3 revenue trends")
-```
-
-### Layer 2 · Context — *Is the right thing in the window?*
-
-Write, select, compress, isolate — the four context operations, one parameter each.
-
-```python
-from praisonaiagents import Agent
-
-agent = Agent(
-    instructions="You are a support engineer.",
-    memory={"user_id": "u-42"},    # write    — persists across runs (needs a user_id)
-    knowledge=["docs/"],           # select   — retrieves only what's relevant
-    context="summarize",           # compress — auto-compacts before the limit
-)
-```
-
-> **Isolate** is `handoffs=[specialist]` — a sub-agent inherits the last few messages and the intersection of your tools, not your whole transcript. [📖 Handoffs](https://docs.praison.ai/docs/concepts/handoffs)
-
-### Layer 3 · Harness — *Can it act, and be checked?*
-
-*Agent = Model + Harness.* Tool dispatch, plus the guides that steer before acting and the sensors that observe after.
-
-```python
-from praisonaiagents import Agent, MCP, tool
-
-@tool
-def deploy(env: str) -> str:
-    """Deploy the current build to an environment."""
-    return f"Deployed to {env}"
-
-agent = Agent(
-    name="ReleaseEngineer",
-    instructions="You are a release engineer.",
-    tools=[deploy, MCP("npx -y @modelcontextprotocol/server-filesystem /tmp")],
-    approval=True,                 # guide — human gate before risky tools run
-)
-agent.start("Deploy to staging, then list the files you can read")
-```
-
-### Layer 4 · Loop — *When do we stop?*
-
-Hard iteration caps, budget ceilings, no-progress detection and completion checks — every brake is explicit.
-
-```python
-from praisonaiagents import Agent, ExecutionConfig
-
-agent = Agent(
-    instructions="Fix the failing tests.",
-    execution=ExecutionConfig(max_iter=30, max_budget=0.50, on_budget_exceeded="stop"),
-    reflection=True,               # completion check — the agent grades its own answer
-    autonomy=True,                 # required to drive the loop with run_autonomous()
-)
-result = agent.run_autonomous("Refactor the auth module", max_iterations=5)
-
-print(result.completion_reason)
-# goal | no_tool_calls | max_iterations | timeout | doom_loop | needs_help | error
-# (with on_budget_exceeded="stop", hitting the cap raises BudgetExceededError,
-#  surfaced here as completion_reason="error")
-```
-
-> **Doom-loop detection is on by default.** Repeated identical tool calls and A→B→A→B oscillation get caught — while a poller whose output keeps changing does not. [📖 Doom Loop Detection](https://docs.praison.ai/docs/features/doom-loop-detection)
-
-### Layer 5 · Graph — *Who runs when, and who checks whom?*
-
-Topology as a versionable artifact: prompt chaining, routing, parallelisation, orchestrator-worker.
-
-```python
-from praisonaiagents import AgentFlow
-from praisonaiagents.workflows import route, parallel, repeat
-
-flow = AgentFlow(steps=[
-    classifier,
-    route({"bug": [bug_agent], "feature": [feature_agent], "default": [triage]}),
-    parallel([reviewer, tester]),                      # fan out, join automatically
-    repeat(editor, until=lambda ctx: "approved" in ctx.previous_result.lower(),
-           max_iterations=3),                          # evaluator–optimizer
-])
-flow.run("Ticket #123: login fails on Safari")
-```
-
-> The same graph is expressible in YAML with no Python at all. [📖 AgentFlow](https://docs.praison.ai/docs/concepts/agentflow)
-
-### ⬡ Outside the stack: Managed Agents — *Where does it actually run?*
-
-The harness is commoditising; **where** the agent executes is the next multiplier. Rather than burning your laptop's CPU, hand an agent a short-lived cloud sandbox — repo, tools and tests run there.
-
-```bash
-pip install praisonai
-```
-
-```python
-from praisonai import Agent, ManagedAgent, LocalManagedConfig
-
-# A. Tools run in a remote sandbox; the agent loop stays local
-sandboxed = ManagedAgent(
-    provider="local", compute="e2b",   # or modal | daytona | flyio | docker | tenki
-    config=LocalManagedConfig(model="gpt-4o-mini", name="RemoteTools"),
-)
-agent = Agent(name="builder", backend=sandboxed)
-
-# B. The entire agent loop runs in the cloud (needs ANTHROPIC_API_KEY;
-#    with no key set, ManagedAgent() falls back to a local loop)
-agent = Agent(name="teacher", backend=ManagedAgent())
-agent.start("Write a Python script that prints the first 10 primes, then run it")
-```
-
-Sandboxes shut themselves down when idle (`auto_shutdown`, `idle_timeout_s`), and a post-setup snapshot is reused so the next run skips the image pull and dependency install. Commit a `.praisonai/environment.yaml` and the environment travels with the repo.
-
-> 📖 [20 runnable examples](examples/python/managed-agents/) · manage sessions with `praisonai managed sessions list <agent-id>` or `praisonai managed sessions resume <session-id> "<prompt>"`
-
-<sub>Stack framing adapted from [The Five-Layer Agent Stack](https://mer.vin/2026/07/five-layer-agent-stack-match-bug-to-right-layer/) and [Agent Harnesses vs Orbs](https://mer.vin/2026/08/agent-harnesses-vs-orbs-why-remote-sandboxes-beat-local-agent-loops/).</sub>
-
----
-
 ## 🌌 The PraisonAI Ecosystem
 
 Start simple with the core SDK, or expand to full visual builders and dashboards when you're ready.
@@ -354,9 +200,9 @@ Powered by 100+ LLMs (OpenAI, Anthropic, Gemini & local models).
 | 🧠 | **Planning Mode** — plan → execute → reason | `planning=True` |
 | 🔍 | **Deep Research** — multi-step autonomous research | [Docs](https://docs.praison.ai/docs/agents/deep-research) |
 | 🤖 | **External Agents** — orchestrate Claude Code, Gemini CLI, Codex | [Docs](https://docs.praison.ai/docs/code/external-agents) |
-| 🔄 | **Agent Handoffs** — seamless conversation passing | `handoffs=[other_agent]` |
+| 🔄 | **Agent Handoffs** — seamless conversation passing | `handoff=True` |
 | 🛡️ | **Guardrails** — input/output validation | [Docs](https://docs.praison.ai/docs/concepts/guardrails) |
-|  | **Web Search + Fetch** — native browsing | `web=True` |
+|  | **Web Search + Fetch** — native browsing | `web_search=True` |
 | 🪞 | **Self Reflection** — agent reviews its own output | [Docs](https://docs.praison.ai/docs/concepts/reflection) |
 | 🔀 | **Workflow Patterns** — route, parallel, loop, repeat | [Docs](https://docs.praison.ai/docs/concepts/agentflow) |
 | 🧠 | **Memory (zero deps)** — works out of the box | `memory=True` |
@@ -366,9 +212,9 @@ Powered by 100+ LLMs (OpenAI, Anthropic, Gemini & local models).
 
 | | Feature | How |
 |--|---------|-----|
-| 💡 | **Prompt Caching** — reduce latency + cost | `caching=True` |
+| 💡 | **Prompt Caching** — reduce latency + cost | `prompt_caching=True` |
 | 💾 | **Sessions + Auto-Save** — persistent state across restarts | `auto_save="my-project"` |
-| 💭 | **Thinking Budgets** — control reasoning depth | `agent.thinking_budget = 1024` |
+| 💭 | **Thinking Budgets** — control reasoning depth | `thinking_budget=1024` |
 | 📚 | **RAG + Quality-Based RAG** — auto quality scoring retrieval | [Docs](https://docs.praison.ai/docs/concepts/rag) |
 | 📊 | **Model Router** — auto-routes to cheapest capable model | [Docs](https://docs.praison.ai/docs/features/model-router) |
 | 🧊 | **Shadow Git Checkpoints** — auto-rollback on failure | [Docs](https://docs.praison.ai/docs/features/checkpoints) |
@@ -495,10 +341,8 @@ from praisonaiagents import Agent, db
 
 agent = Agent(
     name="Assistant",
-    memory={
-        "db": db(database_url="postgresql://localhost/mydb"),
-        "session_id": "my-session",
-    },
+    db=db(database_url="postgresql://localhost/mydb"),
+    session_id="my-session"
 )
 agent.chat("Hello!")  # Auto-persists messages, runs, traces
 ```
@@ -944,16 +788,6 @@ PraisonAI is built for speed, with agent instantiation in around 14μs. This red
 
 ---
 
-<p align="center">
-  <img src=".github/images/agentflow.gif" alt="PraisonAI AgentFlow" width="800" />
-</p>
-
-<p align="center">
-  <img src=".github/images/latest_ai_news_and_crawl_each_url_to_find_info.gif" alt="PraisonAI command execution" width="800" />
-</p>
-
-\* `export TAVILY_API_KEY=xxxxx`
-
 ## 🔍 Langfuse Tracing
 
 ```bash
@@ -1057,10 +891,8 @@ from praisonaiagents import Agent, db
 
 agent = Agent(
     name="Assistant",
-    memory={
-        "db": db(database_url="postgresql://localhost/mydb"),
-        "session_id": "my-session",
-    },
+    db=db(database_url="postgresql://localhost/mydb"),
+    session_id="my-session"
 )
 ```
 
@@ -1076,8 +908,8 @@ from praisonaiagents import Agent
 
 agent = Agent(
     name="Assistant",
-    # Enables file-based memory (no extra deps!)
-    memory={"user_id": "user123"},
+    memory=True,  # Enables file-based memory (no extra deps!)
+    user_id="user123"
 )
 ```
 

api.md

@@ -25,7 +25,7 @@ Methods:
 
 Types:
 ```python
-from praisonaiagents import Agent, AutoAgents, AutoRagAgent, ContextAgent, DeepResearchAgent, ImageAgent, PlanningAgent, PraisonAIAgents, PromptExpanderAgent, QueryRewriterAgent, create_context_agent
+from praisonaiagents import Agent, AutoAgents, AutoRagAgent, ContextAgent, DeepResearchAgent, ImageAgent, PlanningAgent, PromptExpanderAgent, QueryRewriterAgent, create_context_agent
 ```
 
 Methods:
@@ -36,9 +36,13 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">analyze_prompt</a>(prompt: str) -> set</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">auto_memory</a>() -> Optional[bool]</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">auto_memory</a>(value: Optional[bool]) -> None</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>() -> Optional[bool]</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>(value: Optional[bool]) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_history</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_history</a>(value)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_with_context</a>(message: str, context: 'ContextPack', **kwargs) -> str</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>() -> Optional[bool]</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>(value: Optional[bool]) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">clone_for_channel</a>() -> 'Agent'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">close</a>() -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">console</a>() -> Optional[Any]</code>
@@ -79,7 +83,6 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_autonomous_async</a>(prompt: str, max_iterations: Optional[int] = None, timeout_seconds: Optional[float] = None, completion_promise: Optional[str] = None, clear_context: bool = False)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_until</a>(prompt: str, criteria: str = '', threshold: float = 8.0, max_iterations: int = 5, mode: str = 'optimize', on_iteration: Optional[Callable[[Any], None]] = None, verbose: bool = False, goal: Optional[str] = None, goal_criteria: Optional[Any] = None, judge_model: Optional[str] = None) -> 'EvaluationLoopResult'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">run_until_async</a>(prompt: str, criteria: str, threshold: float = 8.0, max_iterations: int = 5, mode: str = 'optimize', on_iteration: Optional[Callable[[Any], None]] = None, verbose: bool = False) -> 'EvaluationLoopResult'</code>
-* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">set_snapshot_root</a>(project_path: str) -> bool</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">skill_manager</a>() -> Optional[Any]</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">store_memory</a>(content: str, memory_type: str = 'short_term', action: str = 'add', **kwargs: Any) -> None</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">stream_emitter</a>() -> Optional[Any]</code>
@@ -176,15 +179,14 @@ Methods:
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">get_schema</a>() -> Dict[str, Any]</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">run</a>(**kwargs) -> Any</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">safe_run</a>(**kwargs) -> ToolResult</code>
-* <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">to_model_output</a>(result: Any) -> Optional[Any]</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate</a>() -> bool</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate_class</a>() -> bool</code>
 * <code title="class BaseTool">BaseTool.<a href="./src/praisonai-agents/praisonaiagents/tools/base.py">validate_schema_roundtrip</a>() -> bool</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">__call__</a>(*args, **kwargs) -> Any</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">check_availability</a>() -> tuple[bool, str]</code>
+* <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">get_schema</a>() -> Dict[str, Any]</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">injected_params</a>() -> Dict[str, Any]</code>
 * <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">run</a>(**kwargs) -> Any</code>
-* <code title="class FunctionTool">FunctionTool.<a href="./src/praisonai-agents/praisonaiagents/tools/decorator.py">to_model_output</a>(result: Any) -> Optional[Any]</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">clear</a>() -> None</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">discover_plugins</a>() -> int</code>
 * <code title="class ToolRegistry">ToolRegistry.<a href="./src/praisonai-agents/praisonaiagents/tools/registry.py">discover_single_file_plugins</a>() -> int</code>
@@ -250,12 +252,9 @@ Methods:
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">delete_memory</a>(memory_id: str, memory_type: Optional[str] = None) -> bool</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">delete_short_term</a>(memory_id: str) -> bool</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">finalize_task_output</a>(content: str, agent_name: str, quality_score: float, threshold: float = 0.7, metrics: Dict[str, Any] = None, task_id: str = None)</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">forget</a>(**kwargs) -> int</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">get_all_memories</a>() -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">get_learn_context</a>() -> str</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">learn</a>()</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">recall</a>(query: str, **kwargs) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">remember</a>(content: str, **kwargs) -> str</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_all</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_entity_only</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_long_term</a>()</code>
@@ -263,8 +262,8 @@ Methods:
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">reset_user_memory</a>()</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search</a>(query: str, user_id: Optional[str] = None, agent_id: Optional[str] = None, run_id: Optional[str] = None, limit: int = 5, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_entity</a>(query: str, limit: int = 5) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_long_term</a>(query: str, limit: int = 5, relevance_cutoff: float = 0.0, min_quality: float = 0.0, rerank: bool = False, metadata_filter: Optional[Dict[str, Any]] = None, user_id: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]</code>
-* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_short_term</a>(query: str, limit: int = 5, min_quality: float = 0.0, relevance_cutoff: float = 0.0, rerank: bool = False, metadata_filter: Optional[Dict[str, Any]] = None, user_id: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]</code>
+* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_long_term</a>(query: str, limit: int = 5, relevance_cutoff: float = 0.0, min_quality: float = 0.0, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
+* <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_short_term</a>(query: str, limit: int = 5, min_quality: float = 0.0, relevance_cutoff: float = 0.0, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_user_memory</a>(user_id: str, query: str, limit: int = 5, rerank: bool = False, **kwargs) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">search_with_quality</a>(query: str, min_quality: float = 0.0, memory_type: Literal['short', 'long'] = 'long', limit: int = 5) -> List[Dict[str, Any]]</code>
 * <code title="class Memory">Memory.<a href="./src/praisonai-agents/praisonaiagents/memory/memory.py">store_entity</a>(name: str, type_: str, desc: str, relations: str)</code>
@@ -510,7 +509,6 @@ Methods:
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">patch</a>(name: str, old_string: str, new_string: str, file_path: Optional[str] = None, replace_all: bool = False, propose: Optional[bool] = None) -> dict</code>
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">patch_skill</a>(name: str, old_string: str, new_string: str, file_path: str = None, replace_all: bool = False, propose: Optional[bool] = None) -> dict</code>
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">reject</a>(identifier: str) -> dict</code>
-* <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">reload</a>() -> Dict[str, List[str]]</code>
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">remove_file</a>(name: str, file_path: str, propose: Optional[bool] = None) -> dict</code>
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">remove_skill_file</a>(name: str, file_path: str, propose: Optional[bool] = None) -> dict</code>
 * <code title="class SkillManager">SkillManager.<a href="./src/praisonai-agents/praisonaiagents/skills/manager.py">resolve</a>(selectors: List[str]) -> List[str]</code>
@@ -570,7 +568,6 @@ Methods:
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_prompts</a>() -> List[dict]</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_resources</a>() -> List[dict]</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">get_tools</a>() -> List[Callable]</code>
-* <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">list_active_server_names</a>() -> set</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">shutdown</a>()</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">to_openai_tool</a>()</code>
 * <code title="class MCP">MCP.<a href="./src/praisonai-agents/praisonaiagents/mcp/mcp.py">with_tool_prefix</a>(prefix: str) -> 'MCP'</code>
@@ -734,7 +731,7 @@ Methods:
 
 Types:
 ```python
-from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, AutoApproveBackend, EmbeddingResult, RetryBackoffConfig, RunOutcome, __version__, aembedding, aembeddings, embedding, embeddings, get_dimensions
+from praisonaiagents import AgentAppConfig, AgentAppProtocol, AgentFlow, AgentManager, AgentOSConfig, AgentOSProtocol, AgentTeam, AutoApproveBackend, EmbeddingResult, RetryBackoffConfig, __version__, aembedding, aembeddings, embedding, embeddings, get_dimensions
 ```
 
 Methods:
@@ -768,7 +765,6 @@ Methods:
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">arun_task</a>(task_id)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">aspawn_sub_agent</a>(agent: Agent, task: Any, completion_callback: Optional[Callable[[SubAgentCompletionEvent], Any]] = None, metadata: Optional[Dict[str, Any]] = None) -> SpawnedSubAgent</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">astart</a>(content = None, return_dict = False, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">astart_for_each</a>(inputs, **kwargs)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">await_for_completions</a>(timeout: Optional[float] = None, agent_ids: Optional[List[str]] = None) -> List[SubAgentCompletionEvent]</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">clean_json_output</a>(output: str) -> str</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">clear_state</a>() -> None</code>
@@ -799,21 +795,16 @@ Methods:
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">run_all_tasks</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">run_task</a>(task_id)</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_output_to_file</a>(task, task_output)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_session_state</a>(session_id: str, include_memory: bool = True) -> bool</code>
+* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">save_session_state</a>(session_id: str, include_memory: bool = True) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">set_state</a>(key: str, value: Any) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">spawn_sub_agent</a>(agent: Agent, task: Any, completion_callback: Optional[Callable[[SubAgentCompletionEvent], Any]] = None, metadata: Optional[Dict[str, Any]] = None) -> SpawnedSubAgent</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">start</a>(content = None, return_dict = False, output = None, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">start_for_each</a>(inputs, **kwargs)</code>
-* <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">stream_emitter</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">todo_list</a>()</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_plan_step_status</a>(step_id: str, status: str) -> bool</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">update_state</a>(updates: Dict) -> None</code>
 * <code title="class AgentTeam">AgentTeam.<a href="./src/praisonai-agents/praisonaiagents/agents/agents.py">wait_for_completions</a>(timeout: Optional[float] = None, agent_ids: Optional[List[str]] = None) -> List[SubAgentCompletionEvent]</code>
 * <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval</a>(request: ApprovalRequest) -> ApprovalDecision</code>
 * <code title="class AutoApproveBackend">AutoApproveBackend.<a href="./src/praisonai-agents/praisonaiagents/approval/backends.py">request_approval_sync</a>(request: ApprovalRequest) -> ApprovalDecision</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">completed</a>(output: Optional[str] = None) -> 'RunOutcome'</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">from_exception</a>(exc: BaseException, output: Optional[str] = None) -> 'RunOutcome'</code>
-* <code title="class RunOutcome">RunOutcome.<a href="./src/praisonai-agents/praisonaiagents/agent/run_outcome.py">succeeded</a>() -> bool</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembedding</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/embed.py">aembeddings</a>(input: Union[str, List[str]], model: str = 'text-embedding-3-small', dimensions: Optional[int] = None, encoding_format: str = 'float', timeout: float = 600.0, api_key: Optional[str] = None, api_base: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs) -> EmbeddingResult</code>
 * <code title="function">praisonaiagents.<a href="./src/praisonai-agents/praisonaiagents/embedding/dimensions.py">get_dimensions</a>(model_name: str) -> int</code>
@@ -822,7 +813,7 @@ Methods:
 
 Types:
 ```python
-from praisonai import Agent, AgentApp, AgentOS, AnthropicManagedAgent, DB, HostedAgent, HostedAgentConfig, LocalAgent, LocalAgentConfig, LocalManagedAgent, LocalManagedConfig, ManagedAgent, ManagedConfig, __version__, arun, run
+from praisonai import Agent, AgentApp, AgentOS, AnthropicManagedAgent, CloudProvider, DB, Deploy, DeployConfig, DeployType, HostedAgent, HostedAgentConfig, LocalAgent, LocalAgentConfig, LocalManagedAgent, LocalManagedConfig, ManagedAgent, ManagedConfig, __version__, arun, run
 ```
 
 # CLI
@@ -949,6 +940,10 @@ Methods:
 * <code title="cli">praisonai schedule suggestion-dismiss <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
 * <code title="cli">praisonai schedule suggestion-propose <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
 * <code title="cli">praisonai schedule suggestions <a href="./src/praisonai/praisonai/cli/commands/schedule.py">--help</a></code>
+* <code title="cli">praisonai standardise check <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise fix <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise init <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
+* <code title="cli">praisonai standardise report <a href="./src/praisonai/praisonai/cli/commands/standardise.py">--help</a></code>
 * <code title="cli">praisonai validate check <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>
 * <code title="cli">praisonai validate schema <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>
 * <code title="cli">praisonai validate validate <a href="./src/praisonai/praisonai/cli/commands/validate.py">--help</a></code>

deploy/README.md

@@ -1,10 +0,0 @@
-# Deployment infra has moved
-
-Deployment assets are no longer at the monorepo root.
-
-| Asset | New location |
-|-------|----------------|
-| Gateway Helm chart | [`src/praisonai-bot/infra/helm/praisonai-gateway/`](../src/praisonai-bot/infra/helm/praisonai-gateway/) |
-| Agents API Helm, Compose, Starters | [`src/praisonai-deploy/infra/`](../src/praisonai-deploy/infra/) |
-
-See [`src/praisonai-deploy/infra/README.md`](../src/praisonai-deploy/infra/README.md).

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.162" \
+    "praisonai>=4.6.155" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.162" \
+    "praisonai>=4.6.155" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.6.162" \
+    "praisonai>=4.6.155" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

examples/doctor/ci_integration.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 CI Integration Example - Using Doctor in CI/CD pipelines
 

examples/endpoints_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 PraisonAI Endpoints Example
 

examples/execution/01_agent_execution_config.py

@@ -36,12 +36,6 @@ if __name__ == "__main__":
     print(f"Custom agent max_rpm: {agent.max_rpm}")
     print(f"Custom agent max_execution_time: {agent.max_execution_time}")
     print(f"Custom agent max_retry_limit: {agent.max_retry_limit}")
-
-    # max_rpm auto-creates a live RateLimiter (not just a stored number)
-    assert agent_rate_limited.max_rpm == 10
-    assert agent_rate_limited._rate_limiter is not None
-    assert agent_rate_limited._rate_limiter.requests_per_minute == 10
-    print(f"Rate-limited agent limiter: {agent_rate_limited._rate_limiter}")
     
     # Test custom agent
     print("\n--- Custom Execution ---")

examples/guardrail_example_fixed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Fixed example demonstrating proper guardrail usage with PraisonAI Agents.
 This addresses the issues reported in issue #875.

examples/managed-agents/persistence/clickhouse_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + ClickHouse Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/mongodb_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + MongoDB Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/mysql_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + MySQL Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/postgres_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + PostgreSQL Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/redis_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + Redis Persistence — Real conversation with session resume.
 

examples/managed-agents/persistence/sqlite_managed.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 ManagedAgent + SQLite Persistence — Real conversation with session resume.
 

examples/mcp_server/custom_tools_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Custom Tools MCP Server Example
 

examples/mcp_server/http_stream_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 HTTP Stream MCP Server Example
 

examples/mcp_server/mcp_client_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MCP Client Example
 

examples/python/agents/context-agent.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Context Agent Example - Basic Usage
 

examples/python/agents/human-review-sequential-team.py

@@ -1,111 +0,0 @@
-"""
-Human Review Between Sequential AgentTeam Tasks
-================================================
-
-Demonstrates a human-in-the-loop review gate between sequential tasks using the
-existing ``on_task_complete`` hook — no new API required.
-
-IMPORTANT — two different ``on_task_complete`` hooks exist, with DIFFERENT
-signatures. Do not confuse them:
-
-    AgentTeam(hooks=MultiAgentHooksConfig(on_task_complete=fn))
-        -> fn(task, task_output)          # team-level; gets the Task and its output
-
-    Task(on_task_complete=fn)
-        -> fn(task_output)                # 1 param: just the TaskOutput
-        -> fn(task_output, metadata)      # 2+ params: TaskOutput + metadata dict
-                                          #   NOTE: NOT (task, task_output)
-
-This example uses the TEAM-level hook so we get ``(task, task_output)`` and can
-filter which tasks require review by ``task.name``.
-
-Approve / reject / edit:
-- approve -> return, workflow continues
-- reject  -> raise; see "stopping the workflow" note below
-- edit    -> mutate ``task_output.raw``; downstream tasks that read this task via
-             ``context=[...]`` pick up the edited text
-
-Stopping the workflow on reject
--------------------------------
-The TEAM-level hook logs and swallows exceptions, so a bare ``raise`` inside it
-does NOT stop the sequential run today. To hard-stop on reject, use the PER-TASK
-callback path with the 1-argument signature and ``fail_on_callback_error=True``
-(see ``review_output`` / ``t1_strict`` at the bottom of this file).
-"""
-
-from praisonaiagents import Agent, Task, AgentTeam
-from praisonaiagents.config.feature_configs import MultiAgentHooksConfig
-
-# Only these task names trigger a human review gate.
-REVIEW_TASKS = {"research"}
-
-
-# --- Team-level review gate: signature is (task, task_output) ---------------
-def review_gate(task, task_output):
-    if task.name not in REVIEW_TASKS:
-        return
-
-    print(f"\n--- Review: {task.name} ---\n{task_output.raw}\n")
-    choice = input("Approve (y), reject (n), edit (e)? ").strip().lower()
-
-    if choice == "n":
-        # NOTE: team-level hook swallows this; see per-task strict path below
-        # for a version that actually halts the workflow.
-        raise RuntimeError(f"Human rejected task '{task.name}'")
-
-    if choice == "e":
-        # task.result is the same object as task_output, so mutating .raw here
-        # propagates to downstream tasks that use context=[this_task].
-        task_output.raw = input("Edited output: ").strip()
-
-
-researcher = Agent(name="Researcher", role="Researcher", goal="Research", backstory="Expert")
-writer = Agent(name="Writer", role="Writer", goal="Write", backstory="Writer")
-
-t1 = Task(
-    name="research",
-    description="List 5 facts about {{topic}}",  # {{...}} is the substitution syntax
-    expected_output="5 bullets",
-    agent=researcher,
-)
-t2 = Task(
-    name="summary",
-    description="Write 3-sentence summary",
-    expected_output="3 sentences",
-    agent=writer,
-    context=[t1],  # reads the (possibly edited) output of t1
-)
-
-team = AgentTeam(
-    agents=[researcher, writer],
-    tasks=[t1, t2],
-    process="sequential",
-    variables={"topic": "REST APIs"},  # substituted into {{topic}} in task descriptions
-    hooks=MultiAgentHooksConfig(on_task_complete=review_gate),
-)
-
-
-# --- Alternative: per-task strict gate that HALTS on reject -----------------
-# Per-task Task.on_task_complete uses the 1-argument signature (task_output).
-# With fail_on_callback_error=True a raised exception re-raises and stops the run.
-def review_output(task_output):
-    print(f"\n--- Review output ---\n{task_output.raw}\n")
-    if input("Approve? (y/n) ").strip().lower() == "n":
-        raise RuntimeError("Human rejected output")
-
-
-t1_strict = Task(
-    name="research",
-    description="List 5 facts about {{topic}}",
-    expected_output="5 bullets",
-    agent=researcher,
-    variables={"topic": "REST APIs"},
-    on_task_complete=review_output,     # signature: (task_output)
-    fail_on_callback_error=True,        # required so reject halts the workflow
-)
-
-
-if __name__ == "__main__":
-    # NOTE: template values come from AgentTeam(variables=...), NOT start(inputs=...).
-    # start() forwards **kwargs but does not consume an ``inputs`` argument.
-    team.start()

examples/python/api/simple-mcp-server.py

@@ -1,15 +1,5 @@
-import threading
-import time
-
 from praisonaiagents import Agent
 
-
 if __name__ == "__main__":
     agent = Agent(name="TweetAgent", instructions="Create a Tweet based on the topic provided")
-    server = threading.Thread(
-        target=lambda: agent.launch(port=8080, protocol="mcp", path="/mcp"),
-        daemon=True,
-    )
-    server.start()
-    time.sleep(2)
-    print("MCP server started on http://127.0.0.1:8080/mcp")
+    agent.launch(port=8080, protocol="mcp", path="/mcp")

examples/python/concepts/csv-processing-agents.py

@@ -86,7 +86,7 @@ def method_1_simple_loop():
         agents=[loop_agent],
         tasks=[loop_task],
         process="workflow",
-        execution="balanced"        # max_iter=10 preset to prevent infinite loops
+        max_iter=10                 # Maximum iterations to prevent infinite loops
     )
     
     print(f"🚀 Starting loop processing of {csv_file}")

examples/python/concepts/knowledge-reranker-example.py

@@ -150,7 +150,7 @@ def main():
     agent = Agent(
         name="AI Research Assistant",
         instructions="You are an AI research assistant. Use your knowledge base to answer questions about artificial intelligence topics.",
-        knowledge={"sources": sample_documents, "rerank": True},
+        knowledge={**rerank_config, "sources": sample_documents},
         llm="gpt-4o-mini"
     )
     

examples/python/concepts/simple-csv-url-processor.py

@@ -64,7 +64,7 @@ def main():
         agents=[url_agent],
         tasks=[url_task],
         process="workflow",
-        execution="balanced"  # max_iter=10 preset; adjust for more URLs
+        max_iter=10  # Adjust based on how many URLs you have
     )
     
     print(f"🚀 Processing URLs from {csv_file}")

examples/python/custom_tools/minimal_latency_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Minimal Example: Latency Tracking for MCP Server
 

examples/python/failover_example.py

@@ -66,7 +66,7 @@ def demonstrate_failover():
         print(f"  {profile_info.get('name', 'unknown')}:")
         print(f"    Status: {profile_info.get('status', 'unknown')}")
         print(f"    Priority: {profile_info.get('priority', 'N/A')}")
-        print(f"    Failures: {profile_info.get('failure_count', 0)}")
+        print(f"    Last error: {profile_info.get('last_error') or 'none'}")
     print()
     
     # Get next available profile

examples/python/gateway_example.py

@@ -7,8 +7,7 @@ multiple agents and managing real-time communication.
 
 from praisonaiagents import Agent, GatewayConfig, SessionConfig
 
-# Configure the gateway using the typed SDK GatewayConfig.
-# In gateway.yaml, the optional ``gateway:`` block is validated at load time (#3050).
+# Configure the gateway
 gateway_config = GatewayConfig(
     host="127.0.0.1",
     port=8765,

examples/python/input/advanced_dynamic_input.py

@@ -141,7 +141,7 @@ class DynamicAgentSystem:
             agents=agents,
             tasks=tasks,
             process=process,
-            output="verbose" if inputs['depth'] == 'detailed' else "silent"
+            verbose=inputs['depth'] == 'detailed'
         )
         
         result = praison_agents.start()

examples/python/managed_agent_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Managed Agent Backend Example — Real end-to-end test.
 

examples/python/memory/advanced-graph-memory-integration.py

@@ -67,7 +67,6 @@ agents_system = AgentTeam(
 print("Starting graph memory demonstration...")
 result = agents_system.start()
 
-result_text = str(result) if result is not None else ""
-print(f"\nGraph Memory Result: {result_text[:200]}...")
+print(f"\nGraph Memory Result: {result[:200]}...")
 print("\n✅ Graph memory integration complete!")
 print("Agent built knowledge graph and performed relationship-aware queries.")

examples/python/mongodb/mongodb_comprehensive_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Comprehensive MongoDB Integration Example for PraisonAI Agents
 

examples/python/mongodb/mongodb_tools_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MongoDB Tools Example for PraisonAI Agents
 

examples/python/sessions/comprehensive-session-management.py

@@ -66,7 +66,7 @@ research_task1 = Task(
 agents_session1 = AgentTeam(
     agents=[research_agent],
     tasks=[research_task1],
-    output="verbose"
+    session=session1, output="verbose"
 )
 
 # Execute first session
@@ -105,7 +105,7 @@ analysis_task = Task(
 agents_session2 = AgentTeam(
     agents=[analysis_agent],
     tasks=[analysis_task], 
-    output="verbose"
+    session=session2, output="verbose"
 )
 
 print("Starting analysis session with previous context...")
@@ -155,7 +155,7 @@ synthesis_task = Task(
 agents_recovery = AgentTeam(
     agents=[synthesis_agent],
     tasks=[synthesis_task],
-    output="verbose"
+    session=recovery_session, output="verbose"
 )
 
 print("Starting recovery session with full context from previous sessions...")
@@ -205,7 +205,7 @@ review_task = Task(
 agents_reviewer = AgentTeam(
     agents=[review_agent],
     tasks=[review_task],
-    output="verbose"
+    session=reviewer_session, output="verbose"
 )
 
 print("Starting peer review session by different user...")

examples/python/stateful/memory-quality-example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Memory Quality Management Example
 

examples/python/tools/exa-tool/SocialMedia_Content_Agents/News_And_Podcast_Aggregator_Agent.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python
+# praisonai: skip=true
 # coding: utf-8
 
 # # News and Podcast Aggregator Agent using Agents

examples/python/tools/searxng/searxng-search.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 SearxNG Search Tool Example
 

examples/python/tools/trafilatura/custom_trafilatura_tools.py

@@ -77,35 +77,13 @@ class TrafilaturaTools:
             except ValueError:
                 # Not an IP address, continue with domain validation
                 pass
-
+            
             # Block common internal domains
             if any(hostname.endswith(domain) for domain in ['.local', '.internal', '.localdomain']):
                 return False
-
+            
             # Block metadata service endpoints
-            if hostname in ['169.254.169.254', 'metadata.google.internal']:
-                return False
-
-            # Resolve the hostname and reject if any address is internal. The
-            # checks above only inspect IP *literals*, so a plain domain (or an
-            # encoded form like a decimal IP or "<internal-ip>.nip.io") still
-            # passes even though it resolves to an internal address. Resolving
-            # here closes that SSRF bypass, mirroring the resolve-and-check
-            # approach already used in praisonaiagents/tools/file_tools.py.
-            import socket
-            default_port = 443 if parsed.scheme == 'https' else 80
-            try:
-                addrinfos = socket.getaddrinfo(hostname, parsed.port or default_port)
-            except socket.gaierror:
-                # Hostname does not resolve; treat it as unsafe.
-                return False
-            for addrinfo in addrinfos:
-                resolved = ipaddress.ip_address(addrinfo[4][0])
-                if (resolved.is_private or resolved.is_reserved
-                        or resolved.is_loopback or resolved.is_link_local):
-                    return False
-
-            return True
+            return hostname not in ['169.254.169.254', 'metadata.google.internal']
             
         except Exception:
             return False
@@ -279,17 +257,7 @@ class TrafilaturaTools:
             "newspaper": None,
             "spider": None
         }
-
-        # Validate the URL once before any fetcher runs so the newspaper and
-        # requests paths below are protected against SSRF, just like the
-        # trafilatura path (which validates inside extract_content).
-        if not self._validate_url(url):
-            error = {"error": f"Invalid or unsafe URL: {url}"}
-            comparison["trafilatura"] = error
-            comparison["newspaper"] = error
-            comparison["spider"] = error
-            return comparison
-
+        
         # Get Trafilatura extraction
         try:
             comparison["trafilatura"] = self.extract_content(url)

examples/recipes/creator_suite/brief_generator_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Brief Generator Example
 

examples/recipes/creator_suite/hook_generator_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Hook Generator Example
 

examples/recipes/creator_suite/news_crawler_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI News Crawler Example
 

examples/recipes/creator_suite/script_writer_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 AI Script Writer Example
 

examples/recipes/example_llm_recipes.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Example: LLM-based Recipes
 

examples/registry/http_registry_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 HTTP Recipe Registry Example
 

examples/run_all_examples.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """Run all examples and collect PASS/SKIP/FAIL results."""
 import subprocess
 import sys

examples/serve/a2a_server_client.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 A2A (Agent-to-Agent) Server and Client Example
 

examples/serve/a2u_events_stream.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 A2U (Agent-to-User) Event Stream Example
 

examples/serve/agents_as_api_router.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Multi-Agent Router as HTTP API Example
 

examples/serve/endpoints_unified_client.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Unified Endpoints Client Example
 

examples/serve/mcp_http_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 MCP HTTP Server Example
 

examples/serve/serve_example.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 PraisonAI Recipe Server Example
 

examples/serve/tools_as_mcp_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Tools as MCP Server Example
 

examples/serve/unified_server.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Unified Server Example
 

examples/terminal_bench/praisonai_code_agent.py

@@ -13,14 +13,15 @@ Usage:
         -n 4
 
 Architecture:
-    Harbor Container → `praisonai code -p --output json "TASK" --dangerously-skip-approval`
+    Harbor Container → `praisonai code "TASK" --dangerously-skip-approval` (headless)
 
 Notes:
     - `--dangerously-skip-approval` sets PRAISON_APPROVAL_MODE=auto +
       PRAISONAI_TOOL_SAFETY=off so the assistant runs fully autonomously in the
       container (no approval hang in a non-TTY session).
-    - The JSON envelope provides token, cost, session, and status metadata while
-      the real exit status still surfaces install/auth/startup failures.
+    - `praisonai code` normally exits 0 and Harbor grades by task verification,
+      so a benchmark miss does not fail the run — but the real exit status is
+      propagated so genuine install/auth/startup failures still surface.
     - The base `praisonai` package is sufficient; heavy `code` extras are not
       required (ACP tools degrade gracefully).
 
@@ -28,7 +29,6 @@ Dependencies:
     pip install harbor praisonai praisonaiagents
 """
 
-import json
 import shlex
 
 try:
@@ -81,21 +81,16 @@ class PraisonAICodeAgent(BaseInstalledAgent):
         model = self.model_name or "openai/gpt-4o-mini"
 
         command = (
-            # Private per-run log (mktemp, 0600) instead of a predictable
-            # /tmp/praisonai_code.log path another process could pre-create as a
-            # symlink to redirect/clobber a file writable by the agent user.
-            "log=$(mktemp /tmp/praisonai_code.XXXXXX.log); "
-            f"praisonai code -p --output json {shlex.quote(instruction)} "
+            f"praisonai code {shlex.quote(instruction)} "
             f"--dangerously-skip-approval "
             f"--model {shlex.quote(model)} "
-            '> "$log" 2>&1; '
+            "> /tmp/praisonai_code.log 2>&1; "
             # Capture the real exit status so install/auth/startup failures still
             # surface instead of being silently masked (Harbor otherwise records a
             # completed attempt for a crashed agent).
             "status=$?; "
-            # Echo the envelope so Harbor captures it for post-run accounting,
-            # then remove the private log.
-            'cat "$log"; rm -f "$log"; '
+            # Tee the log into a stable path so populate_context_post_run can read it.
+            "cp /tmp/praisonai_code.log /tmp/praisonai_code_run.log 2>/dev/null || true; "
             # `praisonai code` normally exits 0 (Harbor grades by task
             # verification), so a genuine benchmark miss won't fail here — but a
             # nonzero status means the assistant itself failed to run.
@@ -105,35 +100,23 @@ class PraisonAICodeAgent(BaseInstalledAgent):
         # `--ae` / job YAML env vars arrive via BaseAgent.extra_env and are wired
         # into the container exec context by Harbor Trial, so no per-exec `env=`
         # is needed here.
-        result = await self.exec_as_agent(
+        await self.exec_as_agent(
             environment,
             command=command,
         )
-        self._last_stdout = getattr(result, "stdout", "") or ""
 
     def populate_context_post_run(self, context: AgentContext) -> None:
-        """Parse the headless JSON envelope into Harbor's accounting fields."""
-        envelope = None
-        for line in reversed(getattr(self, "_last_stdout", "").splitlines()):
-            try:
-                candidate = json.loads(line)
-            except (TypeError, ValueError, json.JSONDecodeError):
-                continue
-            if isinstance(candidate, dict) and "status" in candidate:
-                envelope = candidate
-                break
+        """`praisonai code` exposes no machine-readable metrics headlessly.
 
-        usage = envelope.get("usage", {}) if envelope else {}
-        context.n_input_tokens = usage.get("in")
-        context.n_output_tokens = usage.get("out")
-        context.cost_usd = usage.get("cost")
+        Record identifying metadata; token/cost accounting is not available from
+        the CLI's mixed stdout, so we leave those fields unset rather than guess.
+        """
         context.metadata = {
             "framework": "praisonai",
             "agent_type": "code-cli",
             "agent_name": self.name(),
             "model": self.model_name,
-            "session_id": envelope.get("session_id") if envelope else None,
-            "status": envelope.get("status") if envelope else "unknown",
+            "log_path": "/tmp/praisonai_code.log",
         }
 
 

examples/terminal_bench/test_agent_comparison.py

@@ -1,5 +1,5 @@
-# praisonai: skip=true
 #!/usr/bin/env python3
+# praisonai: skip=true
 """
 Agent Comparison Test - Run 5 tasks with both wrapper and direct agent
 

examples/terminal_bench/test_basic.py

@@ -14,18 +14,18 @@ def test_imports():
     """Test that all required modules can be imported."""
     try:
         from praisonaiagents import Agent
-        print("[OK] Agent imported successfully")
+        print("✅ Agent imported successfully")
         
         from praisonaiagents.tools import execute_command
-        print("[OK] execute_command tool imported successfully")
+        print("✅ execute_command tool imported successfully")
         
         from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
-        print("[OK] Approval system imported successfully")
+        print("✅ Approval system imported successfully")
         
         return True
         
     except ImportError as e:
-        print(f"[FAIL] Import failed: {ascii(e)}")
+        print(f"❌ Import failed: {e}")
         return False
 
 def test_agent_creation():
@@ -40,11 +40,11 @@ def test_agent_creation():
         )
         
         assert agent.name == 'test-agent'
-        print("[OK] Agent creation successful")
+        print("✅ Agent creation successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Agent creation failed: {ascii(e)}")
+        print(f"❌ Agent creation failed: {e}")
         return False
 
 def test_approval_system():
@@ -55,11 +55,11 @@ def test_approval_system():
         registry = get_approval_registry()
         registry.set_backend(AutoApproveBackend())
         
-        print("[OK] Approval system configuration successful")
+        print("✅ Approval system configuration successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Approval system test failed: {ascii(e)}")
+        print(f"❌ Approval system test failed: {e}")
         return False
 
 def test_external_agent_import():
@@ -80,11 +80,11 @@ def test_external_agent_import():
         
         # Now try to import our agent
         import praisonai_external_agent
-        print("[OK] External agent import successful")
+        print("✅ External agent import successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] External agent import failed: {ascii(e)}")
+        print(f"❌ External agent import failed: {e}")
         return False
 
 def test_multi_agent_import():
@@ -104,11 +104,11 @@ def test_multi_agent_import():
         sys.modules['harbor.models.agent.context'] = MagicMock()
         
         import multi_agent_example
-        print("[OK] Multi-agent example import successful")
+        print("✅ Multi-agent example import successful")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Multi-agent example import failed: {ascii(e)}")
+        print(f"❌ Multi-agent example import failed: {e}")
         return False
 
 def test_wrapper_agent_import():
@@ -128,11 +128,11 @@ def test_wrapper_agent_import():
         sys.modules['harbor.models.agent.context'] = MagicMock()
         
         import praisonai_wrapper_agent
-        print("[OK] Wrapper agent import successful (CLI-based approach)")
+        print("✅ Wrapper agent import successful (CLI-based approach)")
         return True
         
     except Exception as e:
-        print(f"[FAIL] Wrapper agent import failed: {ascii(e)}")
+        print(f"❌ Wrapper agent import failed: {e}")
         return False
 
 if __name__ == "__main__":
@@ -152,19 +152,19 @@ if __name__ == "__main__":
     total = len(tests)
     
     for test_name, test_func in tests:
-        print(f"\n[TEST] {test_name}...")
+        print(f"\n🧪 Testing {test_name}...")
         try:
             if test_func():
                 passed += 1
         except Exception as e:
-            print(f"[FAIL] Test {test_name} crashed: {ascii(e)}")
+            print(f"❌ Test {test_name} crashed: {e}")
     
     print("\n" + "=" * 55)
     print(f"Results: {passed}/{total} tests passed")
     
     if passed == total:
-        print("[OK] ALL BASIC TESTS PASSED!")
+        print("🎉 ALL BASIC TESTS PASSED!")
         print("The Terminal-Bench integration components are properly structured.")
     else:
-        print("[FAIL] Some tests failed - check output above")
+        print("❌ Some tests failed - check output above")
         sys.exit(1)

examples/tools/external/hackernews/tool.py

@@ -30,11 +30,9 @@ def main():
     else:
         print(f"Found {len(stories)} top stories:")
         for story in stories:
-            title = story.get("title") or "N/A"
-            url = story.get("url") or "N/A"
-            print(f"  - {title[:50]}...")
+            print(f"  - {story.get('title', 'N/A')[:50]}...")
             print(f"    Score: {story.get('score', 'N/A')} | Comments: {story.get('descendants', 'N/A')}")
-            print(f"    URL: {url[:60]}...")
+            print(f"    URL: {story.get('url', 'N/A')[:60]}...")
             print()
     
     print("✅ Hacker News tool working correctly!")

examples/yaml/gateway.yaml

@@ -19,9 +19,6 @@ agents:
 channels:
   telegram:
     token: "${TELEGRAM_BOT_TOKEN}"
-    # allow_shell: true
-    # auto_approve_shell: false
-    # approval_channel: "123456789"   # Telegram chat ID for shell approvals
     routing:
       dm: "personal"
       group: "support"
@@ -29,9 +26,6 @@ channels:
 
   discord:
     token: "${DISCORD_BOT_TOKEN}"
-    # allow_shell: true
-    # auto_approve_shell: false
-    # approval_channel: "9876543210"  # Discord channel ID (or use home_channel)
     routing:
       dm: "personal"
       channel: "support"
@@ -40,8 +34,6 @@ channels:
   slack:
     token: "${SLACK_BOT_TOKEN}"
     app_token: "${SLACK_APP_TOKEN}"
-    allow_shell: true
-    auto_approve_shell: true
     routing:
       dm: "personal"
       channel: "support"

examples/yaml/teams/research-writer/README.md

@@ -1,64 +0,0 @@
-# Simple Sequential Team (YAML)
-
-A minimal 2-agent sequential team: a **researcher** gathers facts, then a
-**writer** summarizes them. This is the copy-paste starting point for the most
-common multi-agent pattern (2–5 agents, run in order).
-
-```
-research_task  ->  summary_task
- (researcher)       (writer)
-```
-
-## Files
-
-| File | Purpose |
-|------|---------|
-| `agents.yaml` | Roles (who) + their tasks (what); tasks run in declaration order |
-
-> **Which loader applies?** This example uses the canonical single-file format
-> consumed by `AgentsGenerator.generate_crew_and_kickoff()`
-> (`src/praisonai/praisonai/agents_generator.py`). Agents live under `roles:`,
-> each with nested `tasks:`. **Tasks run in the order they are declared** — the
-> researcher's task first, then the writer's. (An optional top-level
-> `dependencies:` block is included to document intent and mirror the canonical
-> fixture, but the roles-file loader sequences by declaration order, so keep
-> tasks in the order you want them to run.) No new loader module is required —
-> this is the existing YAML path.
-
-## Run it
-
-```bash
-export OPENAI_API_KEY=sk-...
-praisonai examples/yaml/teams/research-writer/agents.yaml
-```
-
-This positional-file form is the canonical roles-file entry point. From Python
-the equivalent is `praisonai.run("agents.yaml")` (see
-`src/praisonai/praisonai/_entrypoint.py`), which dispatches to the same
-`AgentsGenerator`.
-
-Change the subject by editing the `topic:` line in `agents.yaml` (interpolated
-into every `{topic}` placeholder).
-
-## When to use this vs a workflow YAML
-
-| You need… | Use | Example |
-|-----------|-----|---------|
-| 2–5 agents, sequential/hierarchical | **This** (`roles:` + `tasks:`) | `agents.yaml` here |
-| Routing by classifier output | workflow YAML | `../../workflows/routing_workflow.yaml` |
-| Parallel branches | workflow YAML | `../../workflows/parallel_workflow.yaml` |
-| Loops / planning / memory | workflow YAML | `../../workflows/complete_workflow.yaml` |
-
-## Python equivalent
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-researcher = Agent(role="Senior Researcher", goal="Find accurate information")
-writer = Agent(role="Report Writer", goal="Turn research into summaries")
-
-t1 = Task(description="Research renewable energy and list 5 key facts", agent=researcher)
-t2 = Task(description="Write a 3-sentence summary from the research", agent=writer, context=[t1])
-
-PraisonAIAgents(agents=[researcher, writer], tasks=[t1, t2]).start()
-```

examples/yaml/teams/research-writer/agents.yaml

@@ -1,34 +0,0 @@
-# yaml-language-server: $schema=https://docs.praison.ai/schemas/agents.schema.json
-# Minimal sequential team: researcher -> writer
-# Run: praisonai examples/yaml/teams/research-writer/agents.yaml
-
-framework: "praisonai"
-topic: "renewable energy"
-
-roles:
-  researcher:
-    role: "Senior Researcher"
-    goal: "Find accurate information about {topic}"
-    backstory: "Expert at concise, factual research."
-    tasks:
-      research_task:
-        description: "Research {topic} and list 5 key facts."
-        expected_output: "A bullet list of 5 facts."
-
-  writer:
-    role: "Report Writer"
-    goal: "Turn research into readable summaries about {topic}"
-    backstory: "Clear technical writer."
-    tasks:
-      summary_task:
-        description: "Write a 3-sentence executive summary from the research."
-        expected_output: "3 sentences, plain text."
-
-# Ordering is by task declaration order above (researcher's task runs first,
-# then the writer's), which is how the roles-file loader sequences tasks.
-# The optional `dependencies:` block below mirrors the canonical fixture
-# (src/praisonai/tests/agents.yaml) and documents intent; the roles-file
-# loader does not consume it, so keep tasks in the order you want them run.
-dependencies:
-  - task: summary_task
-    depends_on: research_task

scripts/apply_e2e_batch3_code_fixes.py

@@ -9,9 +9,15 @@ ROOT = Path(__file__).resolve().parents[1]
 def _prepend_skip(rel: str) -> None:
     path = ROOT / rel
     text = path.read_text(encoding="utf-8")
-    if "# praisonai: skip=true" in text.splitlines()[:3]:
+    lines = text.splitlines(keepends=True)
+    if any("# praisonai: skip=true" in ln for ln in lines[:3]):
         return
-    path.write_text("# praisonai: skip=true\n" + text, encoding="utf-8")
+    # Preserve a shebang on the first line so direct execution still works.
+    if lines and lines[0].startswith("#!"):
+        lines.insert(1, "# praisonai: skip=true\n")
+        path.write_text("".join(lines), encoding="utf-8")
+    else:
+        path.write_text("# praisonai: skip=true\n" + text, encoding="utf-8")
 
 
 def fix_knowledge_reranker() -> None:
@@ -133,6 +139,9 @@ def main() -> None:
     fix_knowledge_reranker()
     print("fixed knowledge-reranker")
 
+    fix_mcp_env_examples()
+    print("fixed MCP environment examples")
+
     # advanced-task-management TaskOutput import
     p = ROOT / "examples/python/tasks/advanced-task-management.py"
     if p.exists():

scripts/apply_e2e_batch3_fixes.py

@@ -1,12 +1,13 @@
 """Apply batch-3 E2E fixes: skip directives for non-runnable examples."""
 from __future__ import annotations
 
+import argparse
 import json
 import re
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
-REPORT = Path(__file__).resolve().parents[2] / "PraisonAI-main-e2e" / "examples-e2e-reports" / "post_merge_20260723_132751" / "report.json"
+DEFAULT_REPORT = Path(__file__).resolve().parents[2] / "PraisonAI-main-e2e" / "examples-e2e-reports" / "post_merge_20260723_132751" / "report.json"
 
 SKIP_LINE = "# praisonai: skip=true"
 SKIP_RE = re.compile(r"^#\s*praisonai:\s*skip\s*=", re.MULTILINE)
@@ -55,13 +56,29 @@ def add_skip(path: Path) -> bool:
     text = path.read_text(encoding="utf-8", errors="ignore")
     if SKIP_RE.search("\n".join(text.splitlines()[:30])):
         return False
-    new_text = SKIP_LINE + "\n" + text.lstrip("\ufeff")
+    text = text.lstrip("\ufeff")
+    lines = text.splitlines(keepends=True)
+    # Preserve a shebang on the first line so direct execution still works.
+    if lines and lines[0].startswith("#!"):
+        lines.insert(1, SKIP_LINE + "\n")
+        new_text = "".join(lines)
+    else:
+        new_text = SKIP_LINE + "\n" + text
     path.write_text(new_text, encoding="utf-8")
     return True
 
 
 def main() -> None:
-    report = json.loads(REPORT.read_text(encoding="utf-8"))
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "report",
+        nargs="?",
+        type=Path,
+        default=DEFAULT_REPORT,
+        help="Path to the E2E report.json (defaults to the audit report path).",
+    )
+    args = parser.parse_args()
+    report = json.loads(args.report.read_text(encoding="utf-8"))
     targets: set[str] = set()
     for it in report.get("results", []):
         if it.get("status") in ("failed", "timeout"):

scripts/check_c14_deploy_imports.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-# C14 import-direction gate for praisonai-deploy.
-set -euo pipefail
-
-cd "$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-CODE_ROOT="${C14_CODE_ROOT:-src/praisonai-code/praisonai_code}"
-DEPLOY_ROOT="${C14_DEPLOY_ROOT:-src/praisonai-deploy/praisonai_deploy}"
-
-ANY_WRAPPER_RE='(^[[:space:]]*from praisonai([[:space:]]|\.)|^[[:space:]]*import praisonai($|\.))'
-ANY_CODE_RE='(^from praisonai_code([[:space:]]|\.)|^import praisonai_code($|\.))'
-ANY_DEPLOY_RE='(^[[:space:]]*from praisonai_deploy([[:space:]]|\.)|^[[:space:]]*import praisonai_deploy($|\.))'
-
-echo "== C14 praisonai_deploy wrapper import gate (must be zero outside bridges) =="
-if command -v rg >/dev/null 2>&1; then
-  MATCHES="$(rg -n "$ANY_WRAPPER_RE" "$DEPLOY_ROOT" --glob '*.py' 2>/dev/null | grep -v '_wrapper_bridge.py' | grep -v '_bootstrap.py' | grep -v '_code_bridge.py' || true)"
-else
-  MATCHES="$(grep -rEn --include='*.py' "$ANY_WRAPPER_RE" "$DEPLOY_ROOT" 2>/dev/null | grep -v '_wrapper_bridge.py' | grep -v '_bootstrap.py' | grep -v '_code_bridge.py' || true)"
-fi
-if [ -n "$MATCHES" ]; then
-  echo "$MATCHES"
-  echo "FAIL: praisonai_deploy imports the praisonai wrapper"
-  exit 1
-fi
-echo "deploy wrapper import gate ok"
-
-echo "== C14 praisonai_deploy module-level praisonai_code import gate =="
-if command -v rg >/dev/null 2>&1; then
-  MATCHES="$(rg -n "$ANY_CODE_RE" "$DEPLOY_ROOT" --glob '*.py' 2>/dev/null | grep -v '_code_bridge.py' | grep -v '_plugin_registry.py' || true)"
-else
-  MATCHES="$(grep -rEn --include='*.py' "$ANY_CODE_RE" "$DEPLOY_ROOT" 2>/dev/null | grep -v '_code_bridge.py' | grep -v '_plugin_registry.py' || true)"
-fi
-if [ -n "$MATCHES" ]; then
-  echo "$MATCHES"
-  echo "FAIL: module-level praisonai_code import in praisonai_deploy"
-  exit 1
-fi
-echo "deploy code import gate ok"
-
-echo "== C14 praisonai-code hot-path gate (no praisonai_deploy at module level) =="
-for f in \
-  "$CODE_ROOT/cli/main.py" \
-  "$CODE_ROOT/cli/app.py" \
-  "$CODE_ROOT/cli/commands/run.py" \
-  "$CODE_ROOT/cli/commands/chat.py" \
-  "$CODE_ROOT/cli/commands/code.py"
-do
-  if [ -f "$f" ] && head -n 80 "$f" | grep -E "$ANY_DEPLOY_RE" 2>/dev/null; then
-    echo "FAIL: module-level praisonai_deploy import in code hot path $f"
-    exit 1
-  fi
-done
-echo "code hot-path gate ok"
-
-echo "C14 import gates passed"

scripts/check_c7_imports.sh

@@ -18,9 +18,7 @@ for f in \
   "$ROOT/cli/app.py" \
   "$ROOT/cli/commands/run.py" \
   "$ROOT/cli/commands/chat.py" \
-  "$ROOT/cli/commands/code.py" \
-  "$ROOT/cli/interactive/async_tui.py" \
-  "$ROOT/cli/interactive/core.py"
+  "$ROOT/cli/commands/code.py"
 do
   if grep -E "$HOT_PATH_RE" "$f" 2>/dev/null; then
     echo "FAIL: module-level wrapper import in $f"

scripts/check_helm_charts.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-# Lint and template-render all Helm charts under package infra/ trees.
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-if ! command -v helm >/dev/null 2>&1; then
-  echo "FAIL: helm CLI not found (install via https://helm.sh/docs/intro/install/)"
-  exit 1
-fi
-
-HELM_ROOTS=(
-  "$ROOT/src/praisonai-bot/infra/helm"
-  "$ROOT/src/praisonai-deploy/infra/helm"
-)
-
-charts=()
-for helm_root in "${HELM_ROOTS[@]}"; do
-  if [ ! -d "$helm_root" ]; then
-    continue
-  fi
-  shopt -s nullglob
-  for chart in "$helm_root"/*/; do
-    if [ -f "${chart}Chart.yaml" ]; then
-      charts+=("$chart")
-    fi
-  done
-  shopt -u nullglob
-done
-
-if [ ${#charts[@]} -eq 0 ]; then
-  echo "No charts found under package infra/helm trees"
-  exit 1
-fi
-
-for chart in "${charts[@]}"; do
-  name="$(basename "$chart")"
-  echo "== helm lint: $name =="
-  helm lint "$chart"
-
-  echo "== helm template: $name =="
-  case "$name" in
-    praisonai-gateway)
-      helm template "ci-smoke-$name" "$chart" \
-        --set auth.existingSecret=ci-smoke-auth \
-        >/dev/null
-      ;;
-    praisonai-agents-api)
-      helm template "ci-smoke-$name" "$chart" \
-        --set auth.existingSecret=ci-smoke-auth \
-        --set postgres.auth.existingSecret=ci-smoke-postgres \
-        >/dev/null
-      ;;
-    *)
-      helm template "ci-smoke-$name" "$chart" >/dev/null
-      ;;
-  esac
-done
-
-echo "Helm chart gates passed (${#charts[@]} chart(s))"

src/praisonai-agents/AGENTS.md

@@ -140,7 +140,7 @@ The **agentic terminal CLI** (`run`, `chat`, `code`, warm runtime, CLI backends,
 
 **Monorepo bootstrap:** `praisonai._bootstrap.ensure_praisonai_code()` adds sibling `src/praisonai-code` to `sys.path` so `PYTHONPATH=src/praisonai-agents:src/praisonai` works without an explicit code entry.
 
-**Install order (CI and local dev):** `praisonai-agents` → `praisonai-code` → `praisonai-bot` → `praisonai-train` → `praisonai-browser` → `praisonai-mcp` → `praisonai-sandbox` → `praisonai-deploy` → `praisonai` (see `.github/actions/install-monorepo-packages`).
+**Install order (CI and local dev):** `praisonai-agents` → `praisonai-code` → `praisonai` (see `.github/actions/install-monorepo-packages`).
 
 **Invocation paths that must remain valid:**
 

src/praisonai-agents/DOCS_PARITY.md

@@ -18,76 +18,76 @@ This report compares **Python SDK feature categories** against **Python document
 | Category | Features | Docs | Lines |
 |----------|----------|------|-------|
 | ✅ AGUI | 1 | 2 | 420 |
-| ✅ Agent | 22 | 50 | 15809 |
-| ✅ Agent-to-Agent (A2A) | 1 | 7 | 2996 |
-| ✅ Agent-to-User (A2U) | 1 | 3 | 689 |
-| ✅ Approval | 1 | 5 | 2537 |
+| ✅ Agent | 21 | 45 | 14056 |
+| ✅ Agent-to-Agent (A2A) | 1 | 7 | 2965 |
+| ✅ Agent-to-User (A2U) | 1 | 3 | 585 |
+| ✅ Approval | 1 | 5 | 2286 |
 | ✅ Audio | 2 | 12 | 1000 |
-| ✅ Auto Generation | 5 | 10 | 3049 |
-| ✅ Autonomy | 3 | 7 | 2744 |
-| ✅ Bots | 7 | 31 | 13314 |
+| ✅ Auto Generation | 5 | 10 | 2868 |
+| ✅ Autonomy | 3 | 7 | 2707 |
+| ✅ Bots | 7 | 28 | 11165 |
 | ✅ Budget | 1 | 1 | 287 |
-| ✅ CLI | 5 | 121 | 36021 |
+| ✅ CLI | 5 | 119 | 33595 |
 | ✅ Chunking | 2 | 2 | 385 |
 | ✅ Citations | 2 | 1 | 202 |
-| ✅ Code Execution | 2 | 14 | 4583 |
+| ✅ Code Execution | 2 | 13 | 3907 |
 | ✅ Conditions | 1 | 3 | 1179 |
-| ✅ Configuration | 3 | 8 | 3047 |
-| ✅ Context Management | 16 | 34 | 13396 |
+| ✅ Configuration | 3 | 7 | 2772 |
+| ✅ Context Management | 16 | 34 | 13204 |
 | ✅ Deep Research | 8 | 2 | 587 |
 | ✅ Display | 6 | 3 | 741 |
 | ✅ Embeddings | 6 | 23 | 2049 |
-| ✅ Evaluation | 1 | 7 | 2905 |
+| ✅ Evaluation | 1 | 7 | 2902 |
 | ✅ Events | 1 | 2 | 749 |
-| ✅ Execution | 3 | 4 | 1562 |
-| ✅ Failover | 2 | 1 | 432 |
-| ✅ Files | 2 | 7 | 2273 |
-| ✅ Flow | 1 | 3 | 788 |
-| ✅ Gateway | 7 | 72 | 26391 |
-| ✅ Guardrails | 4 | 4 | 2017 |
-| ✅ Handoffs | 11 | 6 | 2563 |
-| ✅ Hooks | 2 | 9 | 4317 |
+| ✅ Execution | 3 | 4 | 1528 |
+| ✅ Failover | 2 | 1 | 400 |
+| ✅ Files | 2 | 6 | 1964 |
+| ✅ Flow | 1 | 3 | 777 |
+| ✅ Gateway | 7 | 52 | 18862 |
+| ✅ Guardrails | 4 | 4 | 1673 |
+| ✅ Handoffs | 11 | 6 | 2454 |
+| ✅ Hooks | 2 | 9 | 3985 |
 | ✅ Image | 1 | 11 | 1255 |
-| ✅ Knowledge | 4 | 13 | 4333 |
-| ✅ LLM | 3 | 15 | 5192 |
-| ✅ Loops | 4 | 5 | 1422 |
-| ✅ MCP | 1 | 61 | 13847 |
-| ✅ Memory | 6 | 18 | 7070 |
+| ✅ Knowledge | 4 | 13 | 4160 |
+| ✅ LLM | 3 | 14 | 4767 |
+| ✅ Loops | 4 | 4 | 1202 |
+| ✅ MCP | 1 | 58 | 13322 |
+| ✅ Memory | 6 | 17 | 6635 |
 | ✅ OCR | 2 | 1 | 237 |
-| ✅ Observability | 2 | 23 | 2814 |
+| ✅ Observability | 2 | 23 | 2779 |
 | ✅ Optimizer | 1 | 2 | 792 |
-| ✅ Output | 3 | 5 | 1201 |
+| ✅ Output | 3 | 5 | 1158 |
 | ✅ Parallel Execution | 3 | 2 | 497 |
-| ✅ Planning | 6 | 6 | 1549 |
-| ✅ Plugins | 8 | 4 | 2850 |
-| ✅ Prompts | 2 | 9 | 1965 |
-| ✅ Providers | 1 | 56 | 7735 |
+| ✅ Planning | 6 | 6 | 1545 |
+| ✅ Plugins | 8 | 3 | 1879 |
+| ✅ Prompts | 2 | 8 | 1726 |
+| ✅ Providers | 1 | 55 | 7459 |
 | ✅ Query | 1 | 2 | 736 |
-| ✅ RAG | 5 | 15 | 3003 |
+| ✅ RAG | 5 | 15 | 2936 |
 | ✅ Realtime | 2 | 5 | 668 |
 | ✅ Reflection | 3 | 3 | 680 |
-| ✅ Retrieval | 2 | 5 | 1054 |
+| ✅ Retrieval | 2 | 5 | 1044 |
 | ✅ Routing | 1 | 2 | 430 |
-| ✅ Sandbox | 5 | 6 | 2918 |
-| ✅ Security | 1 | 3 | 3206 |
-| ✅ Sessions | 4 | 17 | 6963 |
-| ✅ Skills | 6 | 15 | 5638 |
-| ✅ Tasks | 2 | 6 | 2819 |
+| ✅ Sandbox | 5 | 6 | 2700 |
+| ✅ Security | 1 | 3 | 2908 |
+| ✅ Sessions | 4 | 13 | 5286 |
+| ✅ Skills | 6 | 13 | 4946 |
+| ✅ Tasks | 2 | 6 | 2743 |
 | ✅ Telemetry | 1 | 2 | 604 |
-| ✅ Templates | 1 | 8 | 1663 |
-| ✅ Tools | 12 | 141 | 41242 |
+| ✅ Templates | 1 | 8 | 1657 |
+| ✅ Tools | 12 | 132 | 37592 |
 | ✅ Tracing | 3 | 2 | 139 |
-| ✅ Vector Store | 1 | 12 | 1211 |
+| ✅ Vector Store | 1 | 12 | 1193 |
 | ✅ Video | 2 | 6 | 649 |
 | ✅ Vision | 2 | 1 | 329 |
-| ✅ Web | 3 | 9 | 2467 |
-| ✅ Workflows | 5 | 16 | 6589 |
+| ✅ Web | 3 | 8 | 2055 |
+| ✅ Workflows | 5 | 16 | 6546 |
 
 ## Documentation Without Features
 
 These docs exist but don't match any implemented feature category:
 
-- ℹ️ Database (42 docs, 6713 lines)
+- ℹ️ Database (40 docs, 6184 lines)
 - ℹ️ Documents (1 docs, 787 lines)
 
 ---

src/praisonai-agents/praisonaiagents/__init__.py

@@ -143,9 +143,9 @@ _LAZY_IMPORTS = {
     'has_toolset': ('praisonaiagents.toolsets', 'has_toolset'),
 
     # Model-family-aware harness (base prompt + edit-format selection)
-    'HarnessProfile': ('praisonaiagents.model_harness.profiles', 'HarnessProfile'),
-    'resolve_harness': ('praisonaiagents.model_harness.profiles', 'resolve_harness'),
-    'register_profile': ('praisonaiagents.model_harness.profiles', 'register_profile'),
+    'HarnessProfile': ('praisonaiagents.model_harness', 'HarnessProfile'),
+    'resolve_harness': ('praisonaiagents.model_harness', 'resolve_harness'),
+    'register_profile': ('praisonaiagents.model_harness', 'register_profile'),
 
     # Run outcomes - typed validation and agent execution results
     'AgentRunOutcome': ('praisonaiagents.run_outcome', 'AgentRunOutcome'),
@@ -258,7 +258,6 @@ _LAZY_IMPORTS = {
     
     # Agent classes
     'Agent': ('praisonaiagents.agent.agent', 'Agent'),
-    'RunOutcome': ('praisonaiagents.agent.run_outcome', 'RunOutcome'),
     'RetryBackoffConfig': ('praisonaiagents.agent.retry_utils', 'RetryBackoffConfig'),
     'BudgetExceededError': ('praisonaiagents.errors', 'BudgetExceededError'),
     
@@ -304,10 +303,9 @@ _LAZY_IMPORTS = {
     'CodeAgent': ('praisonaiagents.agent.code_agent', 'CodeAgent'),
     'CodeConfig': ('praisonaiagents.agent.code_agent', 'CodeConfig'),
     
-    # AgentTeam (primary) / AgentManager, PraisonAIAgents (aliases)
+    # AgentTeam (primary) / AgentManager (alias)
     'AgentTeam': ('praisonaiagents.agents.agents', 'AgentTeam'),
     'AgentManager': ('praisonaiagents.agents.agents', 'AgentManager'),  # Silent alias
-    'PraisonAIAgents': ('praisonaiagents.agents.agents', 'PraisonAIAgents'),  # Silent alias (pre-1.0 name)
     # Note: 'Agents' is handled by _custom_handler for deprecation warning
     'Task': ('praisonaiagents.task.task', 'Task'),
     'AutoAgents': ('praisonaiagents.agents.autoagents', 'AutoAgents'),
@@ -426,7 +424,6 @@ _LAZY_IMPORTS = {
     'WebConfig': ('praisonaiagents.config.feature_configs', 'WebConfig'),
     'OutputConfig': ('praisonaiagents.config.feature_configs', 'OutputConfig'),
     'ExecutionConfig': ('praisonaiagents.config.feature_configs', 'ExecutionConfig'),
-    'PreCompactionMemoryFlushConfig': ('praisonaiagents.config.feature_configs', 'PreCompactionMemoryFlushConfig'),
     'TemplateConfig': ('praisonaiagents.config.feature_configs', 'TemplateConfig'),
     'CachingConfig': ('praisonaiagents.config.feature_configs', 'CachingConfig'),
     'HooksConfig': ('praisonaiagents.config.feature_configs', 'HooksConfig'),
@@ -841,11 +838,9 @@ __all__ = [
     
     # Core classes - the essentials
     'Agent',
-    'RunOutcome',
     'RetryBackoffConfig',
     'AgentTeam',  # Primary class for multi-agent coordination (v1.0+)
     'AgentManager',  # Silent alias for AgentTeam
-    'PraisonAIAgents',  # Silent alias for AgentTeam (pre-1.0 name)
     'Agents',  # Deprecated alias for AgentTeam (emits warning)
     'Task',
     

src/praisonai-agents/praisonaiagents/_lazy.py

@@ -28,11 +28,8 @@ from typing import Any, Callable, Dict, Optional, Tuple
 
 _logger = logging.getLogger(__name__)
 
-# Global cache lock for thread-safe access.
-# Reentrant so that a lazy import which triggers another lazy import on the
-# same thread (e.g. a package attribute that re-exports from a submodule via
-# its own __getattr__) degrades to redundant work instead of self-deadlocking.
-_cache_lock = threading.RLock()
+# Global cache lock for thread-safe access
+_cache_lock = threading.Lock()
 
 # Global module cache
 _module_cache: Dict[str, Any] = {}

src/praisonai-agents/praisonaiagents/_logging.py

@@ -4,6 +4,7 @@ This module consolidates all logging configuration in one place to avoid duplica
 """
 
 import os
+import json
 import logging
 from typing import Any, Dict, List, Optional, Union
 
@@ -195,9 +196,6 @@ class StructuredFormatter(logging.Formatter):
             extra = {k: v for k, v in record.extra_data.items() if k not in self._STANDARD_FIELDS}
             log_data.update(extra)
 
-        # Deferred: json is only needed for opt-in structured logging
-        import json
-
         return json.dumps(log_data)
 
 

src/praisonai-agents/praisonaiagents/agent/__init__.py

@@ -37,15 +37,6 @@ def __getattr__(name):
         from .interrupt import InterruptController
         _lazy_cache[name] = InterruptController
         return InterruptController
-    if name in ('RunOutcome', 'TerminalReason'):
-        from . import run_outcome as _run_outcome_module
-        value = getattr(_run_outcome_module, name)
-        _lazy_cache[name] = value
-        return value
-    if name == 'prompt_prefix_signature':
-        from .prompt_cache import prompt_prefix_signature
-        _lazy_cache[name] = prompt_prefix_signature
-        return prompt_prefix_signature
     
     # Specialized agents - lazy loaded (import rich)
     if name == 'ImageAgent':
@@ -224,9 +215,6 @@ __all__ = [
     'Heartbeat',
     'HeartbeatConfig',
     'InterruptController',
-    'RunOutcome',
-    'TerminalReason',
-    'prompt_prefix_signature',
     'ImageAgent',
     'VideoAgent',
     'VideoConfig',

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -20,7 +20,7 @@ from .async_memory_mixin import AsyncMemoryMixin
 from .tool_execution import ToolExecutionMixin, BackoffPolicy
 from .chat_handler import ChatHandlerMixin
 from .session_manager import SessionManagerMixin
-from .async_safety import AsyncSafeState, DualLock
+from .async_safety import AsyncSafeState
 # NOTE: UnifiedExecutionMixin is deprecated and unused by any production path
 # (Issue #2644). It is kept in the MRO for backward compatibility during the
 # deprecation cycle and will be removed afterwards.
@@ -44,12 +44,6 @@ from ._lazy_display import _get_console, _get_live, _get_display_functions
 
 # Lazy-loaded modules (populated on first use, protected by _lazy_import_lock)
 _lazy_import_lock = threading.Lock()
-
-# Serializes the check-and-enable of the mutually-exclusive process-global
-# output modes (editor/trace/status) so concurrently-constructed Agents cannot
-# both observe "no mode enabled" and clobber each other's callbacks. First
-# mode wins.
-_output_mode_lock = threading.Lock()
 _llm_module = None
 _hooks_module = None
 _stream_emitter_class = None
@@ -865,6 +859,8 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
         planning_tools = None
         planning_reasoning = False
         policy = None
+        background = None
+        checkpoints = None
         output_style = None
         thinking_budget = None
         skills_dirs = None
@@ -932,75 +928,42 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
             editor_output = False
             tool_output_limit = DEFAULT_TOOL_OUTPUT_LIMIT
         
-        # Output modes (editor/trace/status) register callbacks on the same
-        # process-wide, event-type-keyed registry in main.py, so they are
-        # mutually exclusive at the process level. If a *different* mode is
-        # already active (e.g. a prior Agent enabled it), we must not clobber
-        # its callbacks — that would silently route this agent's events through
-        # the other mode's sink (wrong formatting/redaction). First mode wins.
-        def _any_output_mode_enabled():
+        # Enable editor output mode if configured (beginner-friendly, takes priority)
+        # Shows: Step 1: 📄 Creating file: path → ✓ Done
+        if editor_output:
             try:
-                from ..output.editor import is_editor_output_enabled
-                if is_editor_output_enabled():
-                    return True
+                from ..output.editor import enable_editor_output, is_editor_output_enabled
+                if not is_editor_output_enabled():
+                    enable_editor_output(use_color=True)
             except ImportError:
-                pass
+                pass  # Editor module not available
+        # Enable trace output mode if configured
+        # This provides timestamped inline status with duration
+        elif status_trace:
             try:
-                from ..output.trace import is_trace_output_enabled
-                if is_trace_output_enabled():
-                    return True
+                from ..output.trace import enable_trace_output, is_trace_output_enabled
+                if not is_trace_output_enabled():
+                    enable_trace_output(use_color=True, show_timestamps=True)
             except ImportError:
-                pass
+                pass  # Trace module not available
+        # Enable status output mode if configured (simple progress, no timestamps)
+        # This registers callbacks to capture tool calls and final output
+        elif actions_trace:
             try:
-                from ..output.status import is_status_output_enabled
-                if is_status_output_enabled():
-                    return True
+                from ..output.status import enable_status_output, is_status_output_enabled
+                if not is_status_output_enabled():
+                    output_format = "jsonl" if json_output else "text"
+                    # simple_output=True means status preset (no timestamps)
+                    # metrics=True means debug preset (show token/cost info)
+                    enable_status_output(
+                        redact=True,
+                        use_color=True,
+                        format=output_format,
+                        show_timestamps=not simple_output,
+                        show_metrics=metrics
+                    )
             except ImportError:
-                pass
-            return False
-
-        # The check-and-enable below must be atomic across threads: two Agents
-        # constructed concurrently could otherwise both see "no mode enabled"
-        # and clobber each other's callbacks. Only take the lock when a mode is
-        # actually requested (the common silent path stays lock-free).
-        if editor_output or status_trace or actions_trace:
-            with _output_mode_lock:
-                # Enable editor output mode if configured (beginner-friendly, takes priority)
-                # Shows: Step 1: 📄 Creating file: path → ✓ Done
-                if editor_output:
-                    try:
-                        from ..output.editor import enable_editor_output, is_editor_output_enabled
-                        if not is_editor_output_enabled() and not _any_output_mode_enabled():
-                            enable_editor_output(use_color=True)
-                    except ImportError:
-                        pass  # Editor module not available
-                # Enable trace output mode if configured
-                # This provides timestamped inline status with duration
-                elif status_trace:
-                    try:
-                        from ..output.trace import enable_trace_output, is_trace_output_enabled
-                        if not is_trace_output_enabled() and not _any_output_mode_enabled():
-                            enable_trace_output(use_color=True, show_timestamps=True)
-                    except ImportError:
-                        pass  # Trace module not available
-                # Enable status output mode if configured (simple progress, no timestamps)
-                # This registers callbacks to capture tool calls and final output
-                elif actions_trace:
-                    try:
-                        from ..output.status import enable_status_output, is_status_output_enabled
-                        if not is_status_output_enabled() and not _any_output_mode_enabled():
-                            output_format = "jsonl" if json_output else "text"
-                            # simple_output=True means status preset (no timestamps)
-                            # metrics=True means debug preset (show token/cost info)
-                            enable_status_output(
-                                redact=True,
-                                use_color=True,
-                                format=output_format,
-                                show_timestamps=not simple_output,
-                                show_metrics=metrics
-                            )
-                    except ImportError:
-                        pass  # Status module not available
+                pass  # Status module not available
         
         # ─────────────────────────────────────────────────────────────────────
         # Resolve EXECUTION param - FAST PATH for common cases
@@ -1190,26 +1153,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                 default=None,
             )
         
-        # Persist the resolved memory config so clone_for_channel() can forward
-        # (and isolate) it per channel. Without this, clones would receive no
-        # memory config at all (getattr returned None).
-        #
-        # A live Memory/db() backend passed by the user is NOT reconstructable
-        # configuration - it is a single shared store. If we persisted it here,
-        # _isolated_memory_for_clone() would forward the same object by reference
-        # to every per-channel clone, leaking one user's memory into another.
-        # Leave _memory_config unset for live backends so the clone falls back to
-        # _memory_instance and rebuilds an isolated backend.
-        _is_live_backend = (
-            _memory_config is not None
-            and not isinstance(_memory_config, MemoryConfig)
-            and (
-                (hasattr(_memory_config, 'search') and hasattr(_memory_config, 'add'))
-                or hasattr(_memory_config, 'database_url')
-            )
-        )
-        self._memory_config = None if _is_live_backend else _memory_config
-
         # Extract values from resolved memory config
         if _memory_config is not None:
             if hasattr(_memory_config, 'database_url'):
@@ -1413,13 +1356,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                         'rerank': _knowledge_config.rerank,
                         'rerank_model': _knowledge_config.rerank_model,
                     }
-                # Forward embedder settings so they reach Knowledge (mem0).
-                # embedder is a provider shorthand (e.g. "gemini"); embedder_config
-                # is the full mem0 embedder dict. Only override when explicitly set.
-                if _knowledge_config.embedder and _knowledge_config.embedder != "openai":
-                    retrieval_config.setdefault('embedder_provider', _knowledge_config.embedder)
-                if _knowledge_config.embedder_config:
-                    retrieval_config.setdefault('embedder_config', _knowledge_config.embedder_config)
                 knowledge = _knowledge_config.sources if _knowledge_config.sources else None
             elif isinstance(_knowledge_config, list):
                 knowledge = _knowledge_config
@@ -1497,22 +1433,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
         # ─────────────────────────────────────────────────────────────────────
         # Resolve GUARDRAILS param - FAST PATH
         # ─────────────────────────────────────────────────────────────────────
-        # Fail loud instead of silently ignoring policy-string guardrails. The
-        # documented `guardrails=["policy:strict", ...]` shorthand has no
-        # enforcement path wired up, so accepting it silently would run with zero
-        # enforcement — a "safe by default" violation. Checked before resolution
-        # so the clear message wins over the generic resolver's error. Direct
-        # users to the working `Agent(policy=PolicyEngine(...))` param.
-        if isinstance(guardrails, (list, tuple)):
-            from ..config.parse_utils import is_policy_string
-            _policy_strs = [g for g in guardrails if isinstance(g, str) and is_policy_string(g)]
-            if _policy_strs:
-                raise ValueError(
-                    f"Policy-string guardrails {_policy_strs} are not enforced. "
-                    "Use Agent(policy=PolicyEngine(...)) for tool policy enforcement, "
-                    "or pass a validator via guardrails=... / GuardrailConfig(validator=...)."
-                )
-
         # Fast path: None/False -> no guardrails (skip resolve() call)
         if guardrails is None or guardrails is False:
             _guardrails_config = None
@@ -1530,18 +1450,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                 config_class=GuardrailConfig,
             )
         
-        # Same fail-loud guard for GuardrailConfig.policy/.policies passed
-        # directly — those fields are never consumed downstream, so silently
-        # accepting them would also run with zero enforcement.
-        if isinstance(_guardrails_config, GuardrailConfig) and (
-            _guardrails_config.policy is not None or _guardrails_config.policies
-        ):
-            raise ValueError(
-                "GuardrailConfig.policy/.policies are not enforced. "
-                "Use Agent(policy=PolicyEngine(...)) for tool policy enforcement, "
-                "or pass a validator via GuardrailConfig(validator=...)."
-            )
-
         if _guardrails_config is not None:
             if callable(_guardrails_config) and not isinstance(_guardrails_config, type):
                 # Callable validator function
@@ -1747,14 +1655,7 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
             else:
                 llm = model  # model= takes precedence
         
-        # Store rate limiter (optional, zero overhead when None).
-        # Auto-build a RateLimiter from max_rpm when no explicit limiter is
-        # provided so ExecutionConfig(max_rpm=N) actually throttles requests.
-        if max_rpm is not None and max_rpm <= 0:
-            raise ValueError(f"max_rpm must be a positive int, got {max_rpm!r}")
-        if rate_limiter is None and max_rpm is not None:
-            from praisonaiagents.llm.rate_limiter import RateLimiter
-            rate_limiter = RateLimiter(requests_per_minute=max_rpm)
+        # Store rate limiter (optional, zero overhead when None)
         self._rate_limiter = rate_limiter
         
         # Store OpenAI client parameters for lazy initialization (kept separate)
@@ -1766,20 +1667,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
         self.base_url = base_url
         self.api_key = api_key
 
-        # Resolve Agent(retry=...) into LLM init kwargs so the custom-LLM path
-        # (any "provider/model", dict, or base_url config) honours it, instead of
-        # falling back to LLM's hardcoded max_retries=3. self._retry_config is
-        # normalized later (after these branches), so derive the values here from
-        # the raw `retry` argument to forward them into _llm_init_params.
-        _retry_init_params = {}
-        if isinstance(retry, RetryBackoffConfig):
-            _retry_init_params = {'max_retries': retry.max_retries}
-        elif isinstance(retry, dict):
-            _rc = RetryBackoffConfig(**retry)
-            _retry_init_params = {'max_retries': _rc.max_retries}
-        elif retry is False:
-            _retry_init_params = {'max_retries': 0}
-
         # Panel (multi-model) descriptor: "panel:<name>" or {"provider": "panel"}.
         # Resolved lazily into a PanelLLM; composes with the normal tool loop.
         # Detected inline (no heavy import) to keep Agent() construction lazy.
@@ -1821,8 +1708,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                     llm_config['auth'] = auth
                 llm_config['metrics'] = metrics
                 llm_config['max_iter'] = max_iter
-                if _retry_init_params and 'max_retries' not in llm_config:
-                    llm_config.update(_retry_init_params)
                 self._llm_init_params = llm_config
                 self.llm = llm.get('model', Agent._get_default_model())
             else:
@@ -1838,7 +1723,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                     'web_fetch': web_fetch,
                     'prompt_caching': prompt_caching,
                     'claude_memory': claude_memory,
-                    **_retry_init_params,
                 }
                 self.llm = model_name
             self._using_custom_llm = True
@@ -1851,8 +1735,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
                 llm_config['auth'] = auth
             llm_config['metrics'] = metrics
             llm_config['max_iter'] = max_iter
-            if _retry_init_params and 'max_retries' not in llm_config:
-                llm_config.update(_retry_init_params)
             self._llm_init_params = llm_config
             self._using_custom_llm = True
             self.llm = llm_config.get('model', Agent._get_default_model())
@@ -1869,8 +1751,6 @@ class Agent(GoalLoopMixin, SteeringMixin, SandboxMixin, SkillReviewMixin, Unifie
             llm_params['prompt_caching'] = prompt_caching
             llm_params['claude_memory'] = claude_memory
             llm_params['max_iter'] = max_iter
-            if _retry_init_params:
-                llm_params.update(_retry_init_params)
             self._llm_init_params = llm_params
             self._using_custom_llm = True
             self.llm = llm
@@ -2024,15 +1904,6 @@ Your Role: {self.role}\n
 Your Goal: {self.goal}
         """
 
-        # Per-invocation system-prompt append (never persisted). Sourced from the
-        # PRAISONAI_APPEND_SYSTEM_PROMPT env var so every construction path (CLI
-        # code/chat/run, YAML, Python) picks it up without a new constructor
-        # param. Appended at the END of the stable prompt to preserve the
-        # prompt-cache prefix (#2993). No-op when unset/empty.
-        _append_system_prompt = os.environ.get("PRAISONAI_APPEND_SYSTEM_PROMPT")
-        if _append_system_prompt and _append_system_prompt.strip():
-            self.system_prompt = f"{self.system_prompt}\n{_append_system_prompt.strip()}"
-
         # Lazy generate unique ID when needed
         self._agent_id = None
 
@@ -2106,27 +1977,21 @@ Your Goal: {self.goal}
         # None = normal rule flow. Consulted at tool-call approval time.
         self._permission_mode = None
         if isinstance(approval, str) and approval not in ('True', 'False'):
-            # One string entry point for "how much the agent may do":
-            #   • deny-set presets — "safe"/"read_only"/"full"/"off"/"default"
-            #   • PermissionMode presets — "plan"/"bypass"/"accept_edits"/
-            #     "dont_ask" (+ aliases like "yolo", "auto_edit", "reject").
-            # Deny-set presets are matched first so their exact behaviour is
-            # unchanged; anything else falls through to the canonical
-            # PermissionMode resolver, so all spellings share one model.
+            # Permission preset: "safe", "read_only", "full"
             from ..approval.registry import PERMISSION_PRESETS
-            preset_deny = PERMISSION_PRESETS.get(approval.strip().lower())
-            self._approval_backend = None
-            self._approve_all_tools = False
-            self._approval_timeout = 0
-            self._approval_permissions = None
+            preset_deny = PERMISSION_PRESETS.get(approval)
             if preset_deny is not None:
                 self._perm_deny = preset_deny
+                self._approval_backend = None
+                self._approve_all_tools = False
+                self._approval_timeout = 0
+                self._approval_permissions = None
             else:
-                # Not a deny-set preset — try the canonical PermissionMode
-                # presets (plan/bypass/accept_edits/dont_ask + aliases).
-                from ..permissions.rules import PermissionMode
-                self._permission_mode = PermissionMode.resolve(approval)
-                # Unknown string with no mode → treat as no approval.
+                # Unknown string — treat as no approval
+                self._approval_backend = None
+                self._approve_all_tools = False
+                self._approval_timeout = 0
+                self._approval_permissions = None
         elif approval is True:
             from ..approval.backends import AutoApproveBackend
             self._approval_backend = AutoApproveBackend()
@@ -2251,12 +2116,6 @@ Your Goal: {self.goal}
         
         # Store tool retry policy for tool execution with exponential backoff
         self._tool_retry_policy = _tool_config.retry_policy if _tool_config else None
-
-        # Whether undeclared tool names may resolve via the process-global @tool
-        # registry. Default False keeps the agent scoped to its own tools=[...].
-        self._allow_global_tools = (
-            _tool_config.allow_global_tools if _tool_config else False
-        )
         
         # Retry configuration with jittered exponential backoff.
         # Default (retry is None) applies RetryBackoffConfig() so the native
@@ -2365,10 +2224,7 @@ Your Goal: {self.goal}
         # Per-turn tool-name buffer feeding the self-improve review policy.
         # Populated in _execute_tool_with_context, reset each chat turn, and
         # read by _trigger_after_agent_hook when tools_used is not passed.
-        # Guarded by a DualLock (like chat_history) so concurrent chat()/achat()
-        # turns on the same Agent instance don't corrupt each other's buffer.
         self._turn_tools_used = []
-        self._turn_tools_lock = DualLock()
 
         # Database persistence (lazy - no imports until used)
         self._db = db
@@ -2392,6 +2248,8 @@ Your Goal: {self.goal}
         # Agent-centric feature instances (lazy loaded for zero performance impact)
         self._auto_memory = auto_memory
         self._policy = policy
+        self._background = background
+        self._checkpoints = checkpoints
         self._output_style = output_style
         self._thinking_budget = thinking_budget
         
@@ -2463,11 +2321,10 @@ Your Goal: {self.goal}
     def __deepcopy__(self, memo: dict) -> "Agent":
         """Custom deepcopy that creates fresh threading primitives.
 
-        threading primitives cannot be deep-copied on all supported Python
-        versions, while copying an asyncio.Lock can preserve its locked/waiter
-        state. This hook replaces the Agent-owned locks directly, while
-        lock-bearing state wrappers provide their own deepcopy hooks, so the
-        clone receives independent state and fresh locks.
+        threading.RLock (self.__cache_lock) and threading.Lock (self._cost_lock)
+        cannot be deep-copied on CPython < 3.13.  This hook deep-copies every
+        other attribute normally and replaces the locks with new instances so
+        that copy.deepcopy(agent) works in any Python version.
         """
         import copy
         cls = self.__class__
@@ -2478,53 +2335,10 @@ Your Goal: {self.goal}
                 object.__setattr__(result, k, threading.RLock())
             elif k == "_cost_lock":
                 object.__setattr__(result, k, threading.Lock())
-            elif k == "_approvals_lock":
-                object.__setattr__(result, k, asyncio.Lock())
             else:
                 object.__setattr__(result, k, copy.deepcopy(v, memo))
         return result
 
-    def _isolated_memory_for_clone(self):
-        """Resolve a memory backend for a channel clone without sharing one store.
-
-        MemoryConfig/db()/dict configs are re-resolved into a fresh backend per
-        Agent, so they are safe to forward as-is. A live Memory/FileMemory
-        instance, however, is stored by reference on ``_memory_instance``;
-        forwarding it would make every per-channel/per-user clone read and write
-        the same long-term store (leaking one user's history into another). Try
-        to re-instantiate a fresh backend from the instance's own config; if that
-        isn't possible, fall back to sharing (with a warning) so cloning never
-        hard-fails.
-        """
-        mem_cfg = getattr(self, '_memory_config', None)
-        # A stored MemoryConfig/db()/dict config is re-resolved per Agent - safe.
-        if mem_cfg is not None:
-            return mem_cfg
-
-        # No config object: the user passed a live memory backend instance, which
-        # was stored directly on _memory_instance. Rebuild a fresh, isolated one.
-        mem_inst = getattr(self, '_memory_instance', None)
-        if mem_inst is None:
-            return None
-        try:
-            import copy
-            return copy.deepcopy(mem_inst)
-        except Exception:
-            pass
-        # deepcopy failed (e.g. thread-locals/connections). Re-instantiate the same
-        # backend type from its stored config so each clone gets its own store.
-        try:
-            cfg = getattr(mem_inst, 'cfg', None)
-            if cfg is not None:
-                return type(mem_inst)(cfg)
-        except Exception:
-            pass
-        logging.warning(
-            "clone_for_channel: could not isolate the live memory backend; clones "
-            "will share it. Pass memory via MemoryConfig/db() for per-channel isolation."
-        )
-        return mem_inst
-
     def clone_for_channel(self) -> "Agent":
         """Return a fully independent copy of this agent for a gateway channel.
         
@@ -2563,9 +2377,7 @@ Your Goal: {self.goal}
             'handoffs': None,
             
             # Feature configurations - check for actual stored config objects
-            # Isolate a live Memory/FileMemory backend so per-channel clones
-            # don't share one store (would leak one user's history into another).
-            'memory': self._isolated_memory_for_clone(),
+            'memory': getattr(self, '_memory_config', None),
             'knowledge': getattr(self, '_knowledge_config', None), 
             'planning': getattr(self, '_planning_config', None),
             'reflection': getattr(self, '_reflection_config', None),
@@ -2635,10 +2447,10 @@ Your Goal: {self.goal}
                     )
                     # For basic compatibility, include in clone_kwargs if not already set
                     if old_attr == 'allow_code_execution' and clone_kwargs['execution'] is None:
-                        from ..config.feature_configs import ExecutionConfig
+                        from ..config.execution import ExecutionConfig
                         clone_kwargs['execution'] = ExecutionConfig(code_execution=value)
                     elif old_attr == 'auto_save' and clone_kwargs['memory'] is None:
-                        from ..config.feature_configs import MemoryConfig
+                        from ..config.memory import MemoryConfig  
                         clone_kwargs['memory'] = MemoryConfig(auto_save=value)
         
         # Create new Agent instance
@@ -2711,6 +2523,24 @@ Your Goal: {self.goal}
     def policy(self, value: Optional[Any]) -> None:
         self._policy = value
 
+    @property
+    def background(self) -> Optional[bool]:
+        """BackgroundRunner instance for async task execution."""
+        return self._background
+    
+    @background.setter
+    def background(self, value: Optional[bool]) -> None:
+        self._background = value
+
+    @property
+    def checkpoints(self) -> Optional[bool]:
+        """CheckpointService instance for file-level undo/restore."""
+        return self._checkpoints
+    
+    @checkpoints.setter
+    def checkpoints(self, value: Optional[bool]) -> None:
+        self._checkpoints = value
+
     @property
     def output_style(self) -> Optional[str]:
         """OutputStyle instance for response formatting."""
@@ -2873,7 +2703,16 @@ Your Goal: {self.goal}
                 from ..context.models import ContextConfig as _ContextConfig
                 if isinstance(self._context_param, _ContextConfig):
                     # Build ManagerConfig from ContextConfig fields
-                    manager_config = self._manager_config_from_context_config(self._context_param)
+                    manager_config = ManagerConfig(
+                        auto_compact=self._context_param.auto_compact,
+                        compact_threshold=self._context_param.compact_threshold,
+                        strategy=self._context_param.strategy,
+                        output_reserve=self._context_param.output_reserve,
+                        default_tool_output_max=self._context_param.tool_output_max,  # Map field name
+                        protected_tools=list(self._context_param.protected_tools),
+                        keep_recent_turns=self._context_param.keep_recent_turns,
+                        monitor_enabled=self._context_param.monitor.enabled if self._context_param.monitor else False,
+                    )
                     # Check if llm_summarize is enabled in ContextConfig
                     llm_summarize_enabled = getattr(self._context_param, 'llm_summarize', False)
                     if llm_summarize_enabled:
@@ -2902,7 +2741,16 @@ Your Goal: {self.goal}
                 try:
                     from ..context.models import ContextConfig as _ContextConfig
                     context_config = _ContextConfig(**preset_config)
-                    manager_config = self._manager_config_from_context_config(context_config)
+                    manager_config = ManagerConfig(
+                        auto_compact=context_config.auto_compact,
+                        compact_threshold=context_config.compact_threshold,
+                        strategy=context_config.strategy,
+                        output_reserve=context_config.output_reserve,
+                        default_tool_output_max=context_config.tool_output_max,
+                        protected_tools=list(context_config.protected_tools),
+                        keep_recent_turns=context_config.keep_recent_turns,
+                        monitor_enabled=context_config.monitor.enabled if context_config.monitor else False,
+                    )
                     self._context_manager = ContextManager(
                         model=self.llm if isinstance(self.llm, str) else "gpt-4o-mini",
                         config=manager_config,
@@ -2921,7 +2769,16 @@ Your Goal: {self.goal}
             try:
                 from ..context.models import ContextConfig as _ContextConfig
                 context_config = _ContextConfig(**self._context_param)
-                manager_config = self._manager_config_from_context_config(context_config)
+                manager_config = ManagerConfig(
+                    auto_compact=context_config.auto_compact,
+                    compact_threshold=context_config.compact_threshold,
+                    strategy=context_config.strategy,
+                    output_reserve=context_config.output_reserve,
+                    default_tool_output_max=context_config.tool_output_max,
+                    protected_tools=list(context_config.protected_tools),
+                    keep_recent_turns=context_config.keep_recent_turns,
+                    monitor_enabled=context_config.monitor.enabled if context_config.monitor else False,
+                )
                 llm_summarize_enabled = self._context_param.get('llm_summarize', False)
                 self._context_manager = ContextManager(
                     model=self.llm if isinstance(self.llm, str) else "gpt-4o-mini",
@@ -2946,20 +2803,6 @@ Your Goal: {self.goal}
         self._context_manager = value
         self._context_manager_initialized = True
 
-    def _manager_config_from_context_config(self, cc: Any) -> Any:
-        """Build a ManagerConfig from a ContextConfig (single source of truth)."""
-        from ..context import ManagerConfig
-        return ManagerConfig(
-            auto_compact=cc.auto_compact,
-            compact_threshold=cc.compact_threshold,
-            strategy=cc.strategy,
-            output_reserve=cc.output_reserve,
-            default_tool_output_max=cc.tool_output_max,  # Map field name
-            protected_tools=list(cc.protected_tools),
-            keep_recent_turns=cc.keep_recent_turns,
-            monitor_enabled=cc.monitor.enabled if cc.monitor else False,
-        )
-
     def _create_llm_summarize_fn(self) -> Optional[Callable]:
         """
         Create an LLM summarization function using the agent's LLM.
@@ -2987,19 +2830,9 @@ Conversation:
 
 Summary:"""
                 
-                # Use agent's LLM to generate summary. Route this internal,
-                # non-user-facing call through the configured auxiliary
-                # ``small_model`` when set; otherwise fall back to the primary
-                # model (unchanged behaviour).
+                # Use agent's LLM to generate summary
                 client = _get_llm_functions()['get_openai_client'](self.llm, self.base_url, self.api_key)
-                primary_model = self.llm if isinstance(self.llm, str) else None
-                try:
-                    from ..config.loader import get_small_model
-                    model_name = get_small_model(
-                        primary_model=primary_model, fallback="gpt-4o-mini"
-                    ) or "gpt-4o-mini"
-                except Exception:
-                    model_name = primary_model or "gpt-4o-mini"
+                model_name = self.llm if isinstance(self.llm, str) else "gpt-4o-mini"
                 
                 response = client.chat.completions.create(
                     model=model_name,
@@ -3359,44 +3192,7 @@ Summary:"""
     # ================================================================
     # Filesystem tracking convenience methods (powered by FileSnapshot)
     # ================================================================
-
-    def set_snapshot_root(self, project_path: str) -> bool:
-        """Root filesystem change-tracking at ``project_path``.
-
-        Bots/gateway resolve file tools against a per-chat ``Workspace`` and
-        attach it *after* construction, but the FileSnapshot backing
-        :meth:`undo`/:meth:`redo`/:meth:`diff` was created at ``__init__`` time
-        rooted at ``os.getcwd()``. Without this, ``/undo`` tracks the wrong
-        directory (never where the tools actually wrote). Call this once after
-        the workspace is known so change tracking follows the tools.
-
-        Rooting at a new directory clears the undo/redo stacks (they belong to
-        the previous root). A no-op when the root is unchanged. Returns ``True``
-        when a snapshot manager is rooted at ``project_path``.
-        """
-        import os
-        new_root = os.path.abspath(str(project_path))
-        current = self._file_snapshot
-        if current is not None and getattr(current, "project_path", None) == new_root:
-            return True
-        try:
-            from ..snapshot import FileSnapshot
-            snapshot_dir = None
-            cfg = getattr(self, "autonomy_config", None)
-            if isinstance(cfg, dict):
-                snapshot_dir = cfg.get("snapshot_dir")
-            self._file_snapshot = FileSnapshot(
-                project_path=new_root,
-                snapshot_dir=snapshot_dir,
-            )
-            with self._snapshot_lock:
-                self._snapshot_stack = []
-                self._redo_stack = []
-            return True
-        except Exception as e:  # pragma: no cover - git may be unavailable
-            logger.debug(f"Re-rooting FileSnapshot failed: {e}")
-            return False
-
+    
     def undo(self) -> bool:
         """Undo the last set of file changes.
         
@@ -5127,20 +4923,8 @@ Summary:"""
             self._memory_instance = None
             return
         
-        # Determine user_id. A shared constant default (e.g. "praison") would
-        # silently merge different sessions'/users' private memory onto the same
-        # on-disk path. When memory is enabled and no explicit user_id was given,
-        # fall back to a per-instance, non-shared id so agents are isolated by
-        # default. Pass user_id=... explicitly to persist/share memory across runs.
-        mem_user_id = user_id
-        if not mem_user_id:
-            import uuid
-            mem_user_id = f"agent-{uuid.uuid4().hex[:12]}"
-            logging.warning(
-                "Agent memory enabled without an explicit user_id; using an "
-                "auto-generated, non-shared id (%s). Pass user_id=... explicitly "
-                "to persist/share memory across runs.", mem_user_id,
-            )
+        # Determine user_id
+        mem_user_id = user_id or getattr(self, 'user_id', None) or "default"
         
         if memory is True or memory == "file":
             # Use FileMemory (zero dependencies)
@@ -5782,26 +5566,7 @@ Answer:"""
             # Prefer the configured LLM instance (with api_key/base_url/client
             # overrides) over the bare model-name string in self.llm.
             llm = getattr(self, 'llm_instance', None) or getattr(self, 'llm', None)
-            # Guardrail validation is an internal, non-user-facing LLM call.
-            # When it would fall back to the bare primary model-name string
-            # (no explicit LLM instance), route through the auxiliary
-            # ``small_model`` (unset -> primary model, i.e. unchanged behaviour).
-            if isinstance(llm, str):
-                try:
-                    from ..config.loader import get_small_model
-                    llm = get_small_model(primary_model=llm, fallback=llm) or llm
-                except Exception:
-                    pass
             self._guardrail_fn = LLMGuardrail(description=self.guardrail, llm=llm)
-            # A string guardrail is an output-quality validator. Although the
-            # resulting LLMGuardrail also exposes ``validate_input`` (via
-            # GuardrailProtocol), it must NOT be invoked as an input gate here:
-            # doing so would fire an extra, synchronous LLM call on every
-            # chat()/achat() (a hot-path regression, and blocking on the async
-            # event loop). Mark it so input validation skips it. Explicit
-            # GuardrailChain/GuardrailProtocol objects (passed as callables)
-            # remain the only deliberate input surface.
-            self._guardrail_fn._praison_output_only = True
         else:
             raise ValueError("Agent guardrail must be either a callable or a string description")
 
@@ -5863,33 +5628,6 @@ Answer:"""
                 error=f"Agent guardrail validation error: {str(e)}"
             )
 
-    def _validate_input_with_guardrail(self, prompt):
-        """Validate the incoming prompt with the guardrail's input surface.
-
-        Only runs when the configured guardrail exposes a ``validate_input``
-        method (e.g. a ``GuardrailChain`` or an object implementing
-        ``GuardrailProtocol``). Plain callable guardrails and string (output-
-        quality) guardrails have no deliberate input surface and are skipped,
-        so behaviour is unchanged for them.
-
-        Returns (success, result, error). Fails closed on error.
-        """
-        fn = getattr(self, "_guardrail_fn", None)
-        if fn is None or not hasattr(fn, "validate_input"):
-            return True, prompt, None
-        # String guardrails are output-only validators; do not run them as an
-        # input gate (would add a synchronous LLM call to every chat/achat).
-        if getattr(fn, "_praison_output_only", False):
-            return True, prompt, None
-        try:
-            is_valid, result = fn.validate_input(prompt, agent_name=self.name)
-            if is_valid:
-                return True, (result if isinstance(result, str) else prompt), None
-            return False, None, (result if isinstance(result, str) else "Input blocked by guardrail")
-        except Exception as e:
-            logging.error(f"Agent {self.name}: Error in input guardrail validation: {e}")
-            return False, None, f"Input guardrail validation error: {str(e)}"
-
     def _validate_with_guardrail(self, response_text):
         """Validate response with guardrail. Returns (success, result, error)."""
         if not self._guardrail_fn:
@@ -6379,12 +6117,6 @@ Answer:"""
                 images=images,
                 system_prompt=system_prompt
             )
-
-            await self._emit_cli_backend_hook(
-                backend=backend,
-                session_id=session_id,
-                result=result,
-            )
             
             # Check for CLI backend errors
             if result is None:
@@ -6413,55 +6145,10 @@ Answer:"""
             return result.content if result else None
             
         except Exception as e:
-            await self._emit_cli_backend_hook(
-                backend=backend,
-                session_id=session_id,
-                result=None,
-                error=str(e),
-            )
             raise RuntimeError(
                 f"CLI backend execution failed for agent={self.display_name!r}: {e}"
             ) from e
-
-    async def _emit_cli_backend_hook(
-        self,
-        *,
-        backend: Any,
-        session_id: Optional[str],
-        result: Any,
-        error: Optional[str] = None,
-    ) -> None:
-        """Emit the CLI_BACKEND_EXECUTE hook (no-op when no listener is registered).
-
-        Fires on both success and failure so subprocess startup errors and
-        timeouts remain observable. Prompt-bearing argv values are redacted at
-        the payload serialization boundary.
-        """
-        from ..hooks.types import HookEvent
-
-        if not self._hook_runner.registry.has_hooks(HookEvent.CLI_BACKEND_EXECUTE):
-            return
-
-        from ..hooks.events import CliBackendExecuteInput
-        from ..cli_backend.debug import backend_label
-
-        metadata = getattr(result, "metadata", None) or {}
-        hook_input = CliBackendExecuteInput(
-            session_id=session_id,
-            cwd=os.getcwd(),
-            event_name=HookEvent.CLI_BACKEND_EXECUTE.value,
-            timestamp=str(time.time()),
-            agent_name=self.display_name,
-            backend=backend_label(backend),
-            command=metadata.get("command"),
-            content=getattr(result, "content", None),
-            error=error if error is not None else getattr(result, "error", None),
-        )
-        await self._hook_runner.execute(
-            HookEvent.CLI_BACKEND_EXECUTE,
-            hook_input,
-        )
-
+    
     # -------------------------------------------------------------------------
     #                       Resource Lifecycle Management
     # -------------------------------------------------------------------------
@@ -6632,14 +6319,10 @@ Answer:"""
         """Clean up global server registry entries for this agent."""
         if getattr(self, '_agent_id', None) is None:
             return  # No ID generated, nothing registered
-
+            
         try:
-            # Tear down the routes launch() actually registered (module-level
-            # state in execution_mixin.py). ServerRegistry above is a separate,
-            # unpopulated structure and cleaning it up is a no-op.
-            from .execution_mixin import cleanup_launch_registration
-            cleanup_launch_registration(self._agent_id)
-
+            _get_default_server_registry().cleanup_agent_registrations(self._agent_id)
+                    
         except Exception as e:
             import sys
             if sys.meta_path is not None:

src/praisonai-agents/praisonaiagents/agent/async_memory_mixin.py

@@ -7,6 +7,7 @@ async capabilities following the AsyncMemoryProtocol.
 """
 
 import asyncio
+import logging
 from typing import List, Dict, Any, Optional, Union
 from praisonaiagents._logging import get_logger
 from ..memory.protocols import AsyncMemoryProtocol
@@ -84,36 +85,21 @@ class AsyncMemoryMixin:
         if not hasattr(self, '_memory_instance') or self._memory_instance is None:
             logger.debug("No memory configured for async search")
             return []
-
-        # Shared adapters must receive the configured identity explicitly.
-        # FileMemory is already bound to a user-specific path and accepts these
-        # as harmless protocol kwargs.
-        scoped_kwargs = dict(kwargs)
-        config = getattr(self, "_memory_config", None)
-        user_id = getattr(config, "user_id", None)
-        session_id = getattr(config, "session_id", None)
-        if user_id:
-            scoped_kwargs["user_id"] = user_id
-        if session_id:
-            scoped_kwargs["session_id"] = session_id
-            metadata_filter = dict(scoped_kwargs.get("metadata_filter") or {})
-            metadata_filter["session_id"] = session_id
-            scoped_kwargs["metadata_filter"] = metadata_filter
             
         # Check if memory adapter supports async operations
         if isinstance(self._memory_instance, AsyncMemoryProtocol):
             try:
                 if memory_type == "long_term":
-                    return await self._memory_instance.asearch_long_term(query, limit, **scoped_kwargs)
+                    return await self._memory_instance.asearch_long_term(query, limit, **kwargs)
                 else:
-                    return await self._memory_instance.asearch_short_term(query, limit, **scoped_kwargs)
+                    return await self._memory_instance.asearch_short_term(query, limit, **kwargs)
             except Exception as e:
                 logger.error(f"Error in async memory search: {e}")
                 return []
         else:
             # Fallback: run sync memory operations in thread pool
             return await self._run_memory_in_thread(
-                "search", query, memory_type, limit=limit, **scoped_kwargs
+                "search", query, memory_type, limit=limit, **kwargs
             )
     
     async def _run_memory_in_thread(
@@ -230,4 +216,4 @@ class AsyncMemoryMixin:
                 )
                 return False
             return True
-        return False
+        return False

src/praisonai-agents/praisonaiagents/agent/async_safety.py

@@ -5,9 +5,8 @@ This module provides dual-lock abstractions that automatically select
 the appropriate lock type based on the execution context (sync vs async).
 """
 import asyncio
-import copy
 import threading
-from typing import Any
+from typing import Any, Optional, Union
 from contextlib import contextmanager, asynccontextmanager
 from weakref import WeakKeyDictionary
 
@@ -40,12 +39,6 @@ class DualLock:
         """Initialize with separate threading and asyncio locks."""
         self._thread_lock = threading.RLock()  # Re-entrant lock to handle nested acquisitions
         self._async_locks = WeakKeyDictionary()  # Per-event-loop async locks
-
-    def __deepcopy__(self, memo):
-        """Return an unlocked primitive with no event-loop state sharing."""
-        result = type(self)()
-        memo[id(self)] = result
-        return result
     
     @contextmanager
     def sync(self):
@@ -110,15 +103,6 @@ class AsyncSafeState:
     def __init__(self, initial_value: Any = None):
         self.value = initial_value
         self._lock = DualLock()
-
-    def __deepcopy__(self, memo):
-        """Copy the protected value while replacing all lock state."""
-        result = type(self).__new__(type(self))
-        memo[id(self)] = result
-        with self.lock():
-            result.value = copy.deepcopy(self.value, memo)
-        result._lock = DualLock()
-        return result
         
     @contextmanager 
     def lock(self):
@@ -160,4 +144,4 @@ class AsyncSafeState:
         
     def is_async_context(self) -> bool:
         """Check if we're in an async context.""" 
-        return self._lock.is_async_context()
+        return self._lock.is_async_context()

src/praisonai-agents/praisonaiagents/agent/autonomy.py

@@ -34,6 +34,7 @@ Usage:
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any, List, Set
 from enum import Enum
+import logging
 from praisonaiagents._logging import get_logger
 
 logger = get_logger(__name__)
@@ -262,6 +263,17 @@ class AutonomySignal(str, Enum):
         )
         super().__init_subclass__(**kwargs)
 
+def _warn_autonomy_signal():
+    """Emit deprecation warning when AutonomySignal is accessed."""
+    from ..utils.deprecation import warn_deprecated_param
+    warn_deprecated_param(
+        "AutonomySignal",
+        since="1.0.0",
+        removal="2.0.0",
+        alternative="use EscalationSignal from praisonaiagents.escalation.types instead",
+        stacklevel=4
+    )
+
 class AutonomyTrigger:
     """Detects signals from prompts for autonomy decisions.
     

src/praisonai-agents/praisonaiagents/agent/context_agent.py

@@ -22,6 +22,7 @@ from typing import Optional, Any, Dict, Union, List, TYPE_CHECKING
 # Lazy imports for performance - these are only loaded when needed
 _subprocess = None
 _glob = None
+_ast = None
 _asyncio = None
 
 def _get_subprocess():
@@ -40,6 +41,14 @@ def _get_glob():
         _glob = glob
     return _glob
 
+def _get_ast():
+    """Lazy import ast to avoid import-time overhead."""
+    global _ast
+    if _ast is None:
+        import ast
+        _ast = ast
+    return _ast
+
 def _get_asyncio():
     """Lazy import asyncio to avoid import-time overhead."""
     global _asyncio

src/praisonai-agents/praisonaiagents/agent/cost_persistence.py

@@ -12,6 +12,7 @@ Usage::
 """
 
 import json
+import logging
 from praisonaiagents._logging import get_logger
 import os
 import time

src/praisonai-agents/praisonaiagents/agent/deep_research_agent.py

@@ -34,6 +34,7 @@ Example:
 """
 
 import os
+import logging
 from praisonaiagents._logging import get_logger
 import time
 import asyncio

src/praisonai-agents/praisonaiagents/agent/durable.py

@@ -1,448 +0,0 @@
-"""Opt-in durable tool-loop context backed by :class:`RunJournal`."""
-
-from __future__ import annotations
-
-import asyncio
-import contextvars
-import inspect
-import json
-import threading
-from typing import Any, Callable, Dict, List, Optional, Tuple
-from uuid import uuid4
-
-from ..errors import ToolExecutionError
-from ..runtime.journal import (
-    JournalEvent,
-    KIND_ITERATION,
-    KIND_MODEL_DECISION,
-    KIND_TOOL_CALL,
-    KIND_TOOL_RESULT,
-    RunJournal,
-)
-
-
-_active_durable_run: contextvars.ContextVar[Optional["DurableRunContext"]] = (
-    contextvars.ContextVar("praisonai_active_durable_run", default=None)
-)
-_active_idempotency_key: contextvars.ContextVar[Optional[str]] = (
-    contextvars.ContextVar("praisonai_idempotency_key", default=None)
-)
-
-
-def _json_safe(value: Any) -> Any:
-    try:
-        return json.loads(json.dumps(value))
-    except (TypeError, ValueError):
-        return json.loads(json.dumps(value, default=str))
-
-
-def _tool_result_content(result: Any) -> str:
-    if result is None:
-        return "Function returned an empty output"
-    try:
-        return json.dumps(result)
-    except (TypeError, ValueError):
-        return json.dumps({"result": str(result)})
-
-
-def _accepts_idempotency_key(execute_tool_fn: Callable) -> bool:
-    """Return whether an executor accepts the optional durable key contract."""
-    try:
-        parameters = inspect.signature(execute_tool_fn).parameters.values()
-    except (TypeError, ValueError):
-        return False
-    return any(
-        parameter.name == "idempotency_key"
-        or parameter.kind == inspect.Parameter.VAR_KEYWORD
-        for parameter in parameters
-    )
-
-
-class DurableRunContext:
-    """Per-turn journal state; safe for parallel tool-call wrappers."""
-
-    def __init__(
-        self,
-        journal: RunJournal,
-        run_id: str,
-        *,
-        replaying: bool,
-    ) -> None:
-        self.journal = journal
-        self.run_id = run_id
-        self.replaying = replaying
-        self._lock = threading.RLock()
-        self._replay = journal.replay_index(run_id)
-        events = journal.events(run_id)
-        self._next_seq = max((event.seq for event in events), default=-1) + 1
-        self._restored = False
-        self._closed = False
-        self._results_by_tool_call_id: Dict[str, Any] = {}
-        self._pending_by_call_id: Dict[str, Tuple[int, str, Dict[str, Any], str]] = {}
-        self._pending_by_fingerprint: Dict[str, Tuple[int, str, Dict[str, Any], str]] = {}
-        self._recorded_iterations = set()
-        for event in events:
-            if event.kind == KIND_TOOL_RESULT:
-                tool_call_id = event.payload.get("tool_call_id")
-                if tool_call_id:
-                    self._results_by_tool_call_id[str(tool_call_id)] = event.payload.get(
-                        "result"
-                    )
-            elif event.kind == KIND_ITERATION:
-                self._recorded_iterations.add(
-                    int(event.payload.get("index", event.seq))
-                )
-
-        for event in events:
-            if event.kind != KIND_TOOL_CALL:
-                continue
-            call_id = str(event.payload.get("tool_call_id") or "")
-            if not call_id or call_id in self._results_by_tool_call_id:
-                continue
-            name = str(event.payload.get("name") or "")
-            args = event.payload.get("args") or {}
-            key = str(
-                event.payload.get("idempotency_key")
-                or f"{self.run_id}:{event.seq}:{name}"
-            )
-            pending = (event.seq, call_id, args, key)
-            self._pending_by_call_id[call_id] = pending
-            self._pending_by_fingerprint[self._fingerprint(name, args)] = pending
-
-        self._resume_completed_steps = len(self._recorded_iterations)
-
-    @property
-    def completed_steps(self) -> int:
-        return len(self._recorded_iterations)
-
-    @staticmethod
-    def _fingerprint(function_name: str, arguments: Dict[str, Any]) -> str:
-        return f"{function_name}:{json.dumps(_json_safe(arguments), sort_keys=True)}"
-
-    def restore_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Append completed decision/result pairs once, before the next model call."""
-        if not self.replaying or self._restored:
-            return messages
-
-        existing_ids = set()
-        for message in messages:
-            for tool_call in message.get("tool_calls") or []:
-                if isinstance(tool_call, dict) and tool_call.get("id"):
-                    existing_ids.add(str(tool_call["id"]))
-
-        for seq in sorted({key[0] for key in self._replay}):
-            decision = self._replay.get((seq, KIND_MODEL_DECISION))
-            result = self._replay.get((seq, KIND_TOOL_RESULT))
-            if not decision or result is None:
-                continue
-            message = decision.get("message")
-            tool_call_id = result.get("tool_call_id")
-            if not isinstance(message, dict) or not tool_call_id:
-                continue
-            if str(tool_call_id) in existing_ids:
-                continue
-            messages.append(_json_safe(message))
-            messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": str(tool_call_id),
-                    "content": _tool_result_content(result.get("result")),
-                }
-            )
-            existing_ids.add(str(tool_call_id))
-
-        self._restored = True
-        return messages
-
-    def _allocate_step(
-        self,
-        function_name: str,
-        arguments: Dict[str, Any],
-        tool_call_id: Optional[str],
-    ) -> Tuple[int, str, str]:
-        with self._lock:
-            requested_call_id = str(tool_call_id) if tool_call_id is not None else None
-            pending = (
-                self._pending_by_call_id.pop(requested_call_id, None)
-                if requested_call_id
-                else None
-            )
-            fingerprint = self._fingerprint(function_name, arguments)
-            if pending is None and self.replaying:
-                pending = self._pending_by_fingerprint.pop(fingerprint, None)
-            if pending is not None:
-                seq, call_id, _args, idempotency_key = pending
-                self._pending_by_call_id.pop(call_id, None)
-                self._pending_by_fingerprint.pop(fingerprint, None)
-                return seq, call_id, idempotency_key
-
-            seq = self._next_seq
-            self._next_seq += 1
-            call_id = str(tool_call_id or f"{self.run_id}-tool-{seq}")
-            idempotency_key = f"{self.run_id}:{seq}:{function_name}"
-            safe_arguments = _json_safe(arguments)
-            message = {
-                "role": "assistant",
-                "content": "",
-                "tool_calls": [
-                    {
-                        "id": call_id,
-                        "type": "function",
-                        "function": {
-                            "name": function_name,
-                            "arguments": json.dumps(safe_arguments),
-                        },
-                    }
-                ],
-            }
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_MODEL_DECISION,
-                    {"message": message},
-                )
-            )
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_TOOL_CALL,
-                    {
-                        "name": function_name,
-                        "args": safe_arguments,
-                        "tool_call_id": call_id,
-                        "idempotency_key": idempotency_key,
-                    },
-                )
-            )
-            return seq, call_id, idempotency_key
-
-    def _record_result(
-        self,
-        seq: int,
-        tool_call_id: str,
-        result: Any,
-        iteration_index: Optional[int],
-    ) -> Any:
-        safe_result = _json_safe(result)
-        with self._lock:
-            self.journal.append(
-                JournalEvent(
-                    self.run_id,
-                    seq,
-                    KIND_TOOL_RESULT,
-                    {"tool_call_id": tool_call_id, "result": safe_result},
-                )
-            )
-            if iteration_index is None:
-                global_iteration = max(self._recorded_iterations, default=-1) + 1
-            else:
-                global_iteration = self._resume_completed_steps + int(iteration_index)
-            if global_iteration not in self._recorded_iterations:
-                self.journal.append(
-                    JournalEvent(
-                        self.run_id,
-                        global_iteration,
-                        KIND_ITERATION,
-                        {"index": global_iteration},
-                    )
-                )
-                self._recorded_iterations.add(global_iteration)
-            self._results_by_tool_call_id[tool_call_id] = safe_result
-            self._replay[(seq, KIND_TOOL_RESULT)] = {
-                "tool_call_id": tool_call_id,
-                "result": safe_result,
-            }
-        return safe_result
-
-    def _record_terminal_failure(
-        self,
-        seq: int,
-        tool_call_id: str,
-        error: ToolExecutionError,
-        iteration_index: Optional[int],
-    ) -> None:
-        """Persist a fatal tool outcome and make the run non-resumable."""
-        self._record_result(
-            seq,
-            tool_call_id,
-            {
-                "error": str(error),
-                "error_type": type(error).__name__,
-                "is_retryable": bool(error.is_retryable),
-                "terminal": True,
-            },
-            iteration_index,
-        )
-        self.finalize("failed")
-
-    def wrap_sync(self, execute_tool_fn: Optional[Callable]) -> Optional[Callable]:
-        if execute_tool_fn is None:
-            return None
-
-        def execute(function_name, arguments, tool_call_id=None, **kwargs):
-            iteration_index = kwargs.pop("_durable_iteration_index", None)
-            call_id = str(tool_call_id) if tool_call_id is not None else None
-            if call_id and call_id in self._results_by_tool_call_id:
-                return self._results_by_tool_call_id[call_id]
-            seq, call_id, idempotency_key = self._allocate_step(
-                function_name, arguments, tool_call_id
-            )
-            token = _active_idempotency_key.set(idempotency_key)
-            try:
-                call_kwargs = dict(kwargs)
-                call_kwargs["tool_call_id"] = tool_call_id
-                if _accepts_idempotency_key(execute_tool_fn):
-                    call_kwargs["idempotency_key"] = idempotency_key
-                result = execute_tool_fn(function_name, arguments, **call_kwargs)
-            except ToolExecutionError as exc:
-                if not exc.is_retryable:
-                    self._record_terminal_failure(
-                        seq, call_id, exc, iteration_index
-                    )
-                raise
-            except Exception as exc:
-                result = {"error": str(exc)}
-            finally:
-                _active_idempotency_key.reset(token)
-            return self._record_result(seq, call_id, result, iteration_index)
-
-        return execute
-
-    def wrap_async(self, execute_tool_fn: Optional[Callable]) -> Optional[Callable]:
-        if execute_tool_fn is None:
-            return None
-
-        async def execute(function_name, arguments, tool_call_id=None, **kwargs):
-            iteration_index = kwargs.pop("_durable_iteration_index", None)
-            call_id = str(tool_call_id) if tool_call_id is not None else None
-            if call_id and call_id in self._results_by_tool_call_id:
-                return self._results_by_tool_call_id[call_id]
-            seq, call_id, idempotency_key = await asyncio.to_thread(
-                self._allocate_step, function_name, arguments, tool_call_id
-            )
-            token = _active_idempotency_key.set(idempotency_key)
-            try:
-                call_kwargs = dict(kwargs)
-                call_kwargs["tool_call_id"] = tool_call_id
-                if _accepts_idempotency_key(execute_tool_fn):
-                    call_kwargs["idempotency_key"] = idempotency_key
-                result = execute_tool_fn(function_name, arguments, **call_kwargs)
-                if inspect.isawaitable(result):
-                    result = await result
-            except ToolExecutionError as exc:
-                if not exc.is_retryable:
-                    await asyncio.to_thread(
-                        self._record_terminal_failure,
-                        seq,
-                        call_id,
-                        exc,
-                        iteration_index,
-                    )
-                raise
-            except Exception as exc:
-                result = {"error": str(exc)}
-            finally:
-                _active_idempotency_key.reset(token)
-            return await asyncio.to_thread(
-                self._record_result, seq, call_id, result, iteration_index
-            )
-
-        return execute
-
-    def finalize(self, outcome: str = "succeeded") -> None:
-        if not self._closed:
-            self.journal.close_run(self.run_id, outcome)
-            self._closed = True
-
-    def close(self) -> None:
-        self.journal.close()
-
-    async def arestore_messages(
-        self, messages: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        return await asyncio.to_thread(self.restore_messages, messages)
-
-    async def afinalize(self, outcome: str = "succeeded") -> None:
-        await asyncio.to_thread(self.finalize, outcome)
-
-    async def aclose(self) -> None:
-        await asyncio.to_thread(self.close)
-
-
-def begin_durable_run(agent: Any, prompt: str):
-    """Create and activate a context, or return ``(None, None)`` when disabled."""
-    execution = getattr(agent, "execution", None)
-    if execution is None or not getattr(execution, "durable", False):
-        return None, None
-    if _active_durable_run.get() is not None:
-        return None, None
-
-    context = _open_durable_run(agent, prompt)
-    token = _active_durable_run.set(context)
-    return context, token
-
-
-def _open_durable_run(agent: Any, prompt: str) -> DurableRunContext:
-    """Open journal state without mutating the caller's ContextVar."""
-    execution = agent.execution
-
-    journal = RunJournal(getattr(execution, "journal_path", None))
-    resume_run_id = getattr(execution, "resume_run_id", None)
-    replaying = bool(resume_run_id)
-    run_id = str(resume_run_id or uuid4())
-
-    if replaying:
-        metadata = journal.run_meta(run_id)
-        if metadata is None:
-            journal.close()
-            raise ValueError(f"Cannot resume unknown durable run {run_id!r}")
-        if metadata.status != "running":
-            journal.close()
-            raise ValueError(
-                f"Cannot resume terminal durable run {run_id!r} "
-                f"(status={metadata.status!r})"
-            )
-        if metadata.task and metadata.task != prompt:
-            journal.close()
-            raise ValueError(
-                "Resume prompt does not match the prompt recorded for durable "
-                f"run {run_id!r}"
-            )
-
-    journal.open_run(
-        run_id,
-        agent=getattr(agent, "name", ""),
-        task=prompt,
-        metadata={"version": 1, "explicit_resume": replaying},
-    )
-    context = DurableRunContext(journal, run_id, replaying=replaying)
-    agent._last_durable_run_id = run_id
-    return context
-
-
-async def abegin_durable_run(agent: Any, prompt: str):
-    """Async durable-run creation with all SQLite I/O off the event loop."""
-    execution = getattr(agent, "execution", None)
-    if execution is None or not getattr(execution, "durable", False):
-        return None, None
-    if _active_durable_run.get() is not None:
-        return None, None
-    context = await asyncio.to_thread(_open_durable_run, agent, prompt)
-    token = _active_durable_run.set(context)
-    return context, token
-
-
-def end_durable_run(token) -> None:
-    if token is not None:
-        _active_durable_run.reset(token)
-
-
-def get_durable_run() -> Optional[DurableRunContext]:
-    return _active_durable_run.get()
-
-
-def get_durable_idempotency_key() -> Optional[str]:
-    """Return the stable key for the currently executing durable tool call."""
-    return _active_idempotency_key.get()

src/praisonai-agents/praisonaiagents/agent/execution_mixin.py

@@ -28,44 +28,6 @@ _server_started: Dict[int, bool] = {}
 _registered_agents: Dict[int, Dict[str, str]] = {}
 _shared_apps: Dict[int, Any] = {}
 
-
-def cleanup_launch_registration(agent_id: str) -> None:
-    """Remove launch() endpoints registered for ``agent_id`` from the shared
-    HTTP state that ``Agent.launch()`` actually populates.
-
-    ``Agent.launch()`` writes routes into the module-level ``_registered_agents``
-    and ``_shared_apps`` dicts above. This tears those routes back down so a
-    closed agent's endpoint stops accepting requests and the request handler
-    closure no longer keeps the Agent object graph alive.
-    """
-    with _server_lock:
-        for port, paths in list(_registered_agents.items()):
-            stale_paths = [p for p, aid in paths.items() if aid == agent_id]
-            for p in stale_paths:
-                del paths[p]
-                app = _shared_apps.get(port)
-                if app is not None:
-                    try:
-                        # Only drop the agent-owned POST route. launch() always
-                        # registers the handler via ``.post(path)``, so filtering
-                        # on both path AND method preserves unrelated routes that
-                        # share the path with a different verb (e.g. the built-in
-                        # GET /health and GET /).
-                        app.router.routes = [
-                            r for r in app.router.routes
-                            if not (
-                                getattr(r, "path", None) == p
-                                and "POST" in (getattr(r, "methods", None) or set())
-                            )
-                        ]
-                        # Invalidate cached OpenAPI schema so removed routes
-                        # disappear from /openapi.json and /docs.
-                        app.openapi_schema = None
-                    except Exception:
-                        pass
-            if not paths:
-                _registered_agents.pop(port, None)
-
 if TYPE_CHECKING:
     pass
 
@@ -163,30 +125,16 @@ class ExecutionMixin:
         
         Args:
             prompt: The input prompt to process
-            **kwargs: Additional arguments passed to achat():
-                - return_outcome (bool): If True, return a canonical
-                  ``RunOutcome`` (completed | hard_timeout | cancelled |
-                  aborted | failed) instead of raising on error/timeout/
-                  cancellation. Default: False.
-                - timeout (float): When used with ``return_outcome=True``,
-                  a hard timeout budget for the run.
+            **kwargs: Additional arguments passed to achat()
             
         Returns:
-            The agent's response as a string, or AutonomyResult if autonomy
-            enabled, or a ``RunOutcome`` when ``return_outcome=True``.
+            The agent's response as a string, or AutonomyResult if autonomy enabled
             
         Note:
             If autonomy=True was set on the agent, astart() automatically uses
             the autonomous loop (run_autonomous_async) instead of single-turn chat.
         """
         import sys
-
-        return_outcome = kwargs.pop('return_outcome', False)
-        if return_outcome:
-            outcome_timeout = kwargs.pop('timeout', None)
-            return await self._astart_with_outcome(
-                prompt, outcome_timeout, **kwargs
-            )
         
         # ─────────────────────────────────────────────────────────────────────
         # UNIFIED AUTONOMY API: If autonomy is enabled, route to run_autonomous_async
@@ -248,57 +196,6 @@ class ExecutionMixin:
         kwargs['stream'] = stream_requested
         return await self.achat(prompt, **kwargs)
 
-    async def _astart_with_outcome(self, prompt, timeout=None, **kwargs):
-        """Run astart() and normalise its result/exception into a RunOutcome.
-
-        Optionally enforces a hard run-level timeout budget. The budget is the
-        *authoritative* source of ``hard_timeout``: when our own
-        ``asyncio.wait_for`` fires we return ``hard_timeout`` directly, so a
-        nested operation timeout (which surfaces as a generic
-        ``asyncio.TimeoutError`` from inside the run) is never misreported as a
-        run-budget timeout — it falls through to ``failed`` via
-        ``RunOutcome.from_exception``.
-
-        External ``asyncio.CancelledError`` (e.g. the enclosing task being
-        cancelled during host shutdown) is re-raised, not swallowed, so
-        cooperative cancellation semantics are honoured.
-        """
-        import asyncio
-        from .run_outcome import RunOutcome
-
-        enforce_budget = timeout is not None and timeout > 0
-
-        # Enforce the run budget with an explicit deadline on a task we own, so
-        # that only *our* budget expiry maps to hard_timeout. This deliberately
-        # avoids ``asyncio.wait_for`` catching a bare inner ``TimeoutError``:
-        # a nested operation timeout raised inside the run must fall through to
-        # ``failed`` rather than be misreported as a run-budget ``hard_timeout``.
-        try:
-            if enforce_budget:
-                task = asyncio.ensure_future(self.astart(prompt, **kwargs))
-                try:
-                    done, _ = await asyncio.wait({task}, timeout=timeout)
-                except asyncio.CancelledError:
-                    # Enclosing task cancelled (e.g. host shutdown): cancel the
-                    # child and propagate so cooperative cancellation is honoured.
-                    task.cancel()
-                    raise
-                if task not in done:
-                    # Our budget expired first: authoritative, sticky hard_timeout.
-                    task.cancel()
-                    return RunOutcome(reason="hard_timeout")
-                result = task.result()
-            else:
-                result = await self.astart(prompt, **kwargs)
-        except asyncio.CancelledError:
-            # External cancellation of the awaiting task: honour asyncio
-            # cancellation / host shutdown by propagating instead of converting
-            # it into a benign RunOutcome.
-            raise
-        except Exception as exc:  # noqa: BLE001 - normalised into outcome
-            return RunOutcome.from_exception(exc)
-        return RunOutcome.completed(output=str(result) if result is not None else None)
-
     def run(self, prompt: str, **kwargs: Any) -> Optional[str]:
         """Execute agent silently and return structured result.
         
@@ -311,14 +208,9 @@ class ExecutionMixin:
             **kwargs: Additional arguments:
                 - stream (bool): Force streaming if True. Default: False
                 - output (str): Output preset override (rarely needed)
-                - return_outcome (bool): If True, return a canonical
-                  ``RunOutcome`` describing how the run ended
-                  (completed | hard_timeout | cancelled | aborted | failed)
-                  instead of raising on error. Default: False.
                 
         Returns:
-            The agent's response as a string, or a ``RunOutcome`` when
-            ``return_outcome=True``.
+            The agent's response as a string
             
         Example:
             ```python
@@ -335,14 +227,8 @@ class ExecutionMixin:
             - Background processing
             - API endpoints
         """
-        return_outcome = kwargs.pop('return_outcome', False)
-
         # Check if external managed backend is configured
         if hasattr(self, 'backend') and self.backend is not None:
-            if return_outcome:
-                return self._run_with_outcome(
-                    lambda: self._delegate_to_backend(prompt, **kwargs)
-                )
             return self._delegate_to_backend(prompt, **kwargs)
         
         # Production defaults: no streaming, no display
@@ -356,34 +242,17 @@ class ExecutionMixin:
         
         # Load history context
         self._load_history_context()
-
-        def _execute():
-            if self.planning:
-                _result = self._start_with_planning(prompt, **kwargs)
-            else:
-                _result = self.chat(prompt, **kwargs)
-            # Auto-save session if enabled
-            self._auto_save_session()
-            return _result
-
-        if return_outcome:
-            return self._run_with_outcome(_execute)
-
-        return _execute()
-
-    def _run_with_outcome(self, executor):
-        """Run ``executor`` and normalise its result/exception into a RunOutcome.
-
-        Keeps the canonical terminal-outcome logic in one place so callers get
-        a single, closed description of how the run ended instead of inferring
-        it from exception identity.
-        """
-        from .run_outcome import RunOutcome
-        try:
-            result = executor()
-        except BaseException as exc:  # noqa: BLE001 - normalised into outcome
-            return RunOutcome.from_exception(exc)
-        return RunOutcome.completed(output=str(result) if result is not None else None)
+        
+        # Check if planning mode is enabled
+        if self.planning:
+            result = self._start_with_planning(prompt, **kwargs)
+        else:
+            result = self.chat(prompt, **kwargs)
+        
+        # Auto-save session if enabled
+        self._auto_save_session()
+        
+        return result
 
     def _delegate_to_backend(self, prompt: str, **kwargs) -> Optional[str]:
         """Delegate execution to external managed backend (e.g., ManagedAgentIntegration).
@@ -437,40 +306,7 @@ class ExecutionMixin:
             self._auto_save_session()
         
         return result
-
-    async def _adelegate_to_backend(self, prompt: str, **kwargs) -> Optional[str]:
-        """Async delegation to an external managed backend (async parity with
-        ``_delegate_to_backend``). Awaits the backend's async ``execute`` directly
-        instead of bridging through a worker thread, then records prompt/response
-        in chat_history so session management stays consistent.
-        """
-        from praisonaiagents.agent.protocols import ManagedBackendProtocol
-        if not (isinstance(self.backend, ManagedBackendProtocol) or hasattr(self.backend, 'execute')):
-            raise RuntimeError(f"Backend {type(self.backend).__name__} does not support execute() method")
-
-        result = await self.backend.execute(prompt, **kwargs)
-
-        if result is not None:
-            self._append_to_chat_history({"role": "user", "content": prompt})
-            self._append_to_chat_history({"role": "assistant", "content": str(result)})
-            if hasattr(self.backend, 'managed_session_id'):
-                msid = self.backend.managed_session_id
-                if msid and self._session_store is not None:
-                    try:
-                        sid = getattr(self, 'auto_save', None) or getattr(self, '_session_id', None)
-                        if sid and hasattr(self._session_store, 'set_gateway_info'):
-                            self._session_store.set_gateway_info(sid, gateway_session_id=msid)
-                    except Exception as e:
-                        logger.warning(
-                            "Session gateway linkage failed: %s",
-                            e,
-                            extra={"session_id": sid, "managed_session_id": msid},
-                            exc_info=True,
-                        )
-            self._auto_save_session()
-
-        return result
-
+    
     def _execute_backend_sync(self, prompt: str, **kwargs) -> Optional[str]:
         """Execute backend in sync mode, handling async backends."""
         try:
@@ -570,90 +406,39 @@ class ExecutionMixin:
                     thread.join()
                     
                 except RuntimeError:
-                    # No event loop (the common script/CLI case). Drive the
-                    # backend's async generator from a background thread and
-                    # push each chunk through a queue as it arrives, so the
-                    # caller receives chunks incrementally instead of only
-                    # after the whole response has been buffered. Mirrors the
-                    # running-loop branch above.
-                    import threading
-                    import queue
-                    # Bounded queue so an abandoned consumer applies
-                    # back-pressure instead of letting the producer fill memory
-                    # unbounded. ``cancel_event`` lets the producer stop early
-                    # when the caller closes the generator.
-                    bridge_queue = queue.Queue(maxsize=64)
-                    cancel_event = threading.Event()
-
-                    def run_in_thread_noloop():
-                        new_loop = asyncio.new_event_loop()
-                        asyncio.set_event_loop(new_loop)
-                        try:
-                            async def pump():
-                                try:
-                                    async for item in self.backend.stream(prompt, **kwargs):
-                                        if cancel_event.is_set():
-                                            break
-                                        # Block until space is available or the
-                                        # consumer signals cancellation, so we
-                                        # never spin nor grow the queue forever.
-                                        while not cancel_event.is_set():
-                                            try:
-                                                bridge_queue.put(('item', item), timeout=0.1)
-                                                break
-                                            except queue.Full:
-                                                continue
-                                    if not cancel_event.is_set():
-                                        bridge_queue.put(('done', None))
-                                except Exception as e:
-                                    if not cancel_event.is_set():
-                                        bridge_queue.put(('error', e))
-
-                            new_loop.run_until_complete(pump())
-                        finally:
-                            new_loop.close()
-
-                    # Daemon thread so a stalled/abandoned producer can never
-                    # block interpreter shutdown.
-                    thread = threading.Thread(target=run_in_thread_noloop, daemon=True)
-                    thread.start()
-
-                    try:
-                        while True:
-                            msg_type, data = bridge_queue.get()
-                            if msg_type == 'item':
-                                item = data
-                                # Same conversion logic as the running-loop branch.
-                                if isinstance(item, dict):
-                                    if item.get('type') == 'agent.message':
-                                        content = item.get('content', [])
-                                        if isinstance(content, list):
-                                            text_parts = []
-                                            for block in content:
-                                                if isinstance(block, dict) and block.get('type') == 'text':
-                                                    text_parts.append(block.get('text', ''))
-                                                elif isinstance(block, str):
-                                                    text_parts.append(block)
-                                            if text_parts:
-                                                yield ''.join(text_parts)
-                                        elif isinstance(content, str):
-                                            yield content
-                                elif isinstance(item, str):
-                                    yield item
-                            elif msg_type == 'done':
-                                break
-                            elif msg_type == 'error':
-                                raise data
-                    finally:
-                        # Runs on normal completion AND on early generator
-                        # close/GC: signal the producer to stop, drain one slot
-                        # so a blocked put() can observe the cancel, and join.
-                        cancel_event.set()
-                        try:
-                            bridge_queue.get_nowait()
-                        except queue.Empty:
-                            pass
-                        thread.join(timeout=5)
+                    # No event loop - can run directly
+                    async def run_stream():
+                        async for item in self.backend.stream(prompt, **kwargs):
+                            yield item
+                    
+                    # Use asyncio.run for each item (not ideal but works)
+                    async_gen = run_stream()
+                    
+                    async def collect_all():
+                        results = []
+                        async for item in async_gen:
+                            results.append(item)
+                        return results
+                    
+                    results = asyncio.run(collect_all())
+                    for item in results:
+                        # Similar conversion logic
+                        if isinstance(item, dict):
+                            if item.get('type') == 'agent.message':
+                                content = item.get('content', [])
+                                if isinstance(content, list):
+                                    text_parts = []
+                                    for block in content:
+                                        if isinstance(block, dict) and block.get('type') == 'text':
+                                            text_parts.append(block.get('text', ''))
+                                        elif isinstance(block, str):
+                                            text_parts.append(block)
+                                    if text_parts:
+                                        yield ''.join(text_parts)
+                                elif isinstance(content, str):
+                                    yield content
+                        elif isinstance(item, str):
+                            yield item
             
             return sync_stream()
             
@@ -1361,52 +1146,13 @@ Write the complete compiled report:"""
         # Record the tool name for this turn so the self-improve review policy
         # sees async tool usage too (issue #3037). Mirrors the sync path in
         # _execute_tool_with_context; skipped during a guarded review turn so
-        # the review's own calls are not tracked and cannot recurse. Locked so
-        # concurrent turns on the same Agent don't corrupt the buffer (#3307).
-        self._record_turn_tool(function_name)
-
-        # Result-aware tool-loop detection (async parity with the sync path in
-        # tool_execution.py). Without this, an agent driven via achat()/astart()
-        # that repeatedly calls the same tool with the same args gets no
-        # stuck-loop detection, while the identical sync agent would be caught.
-        # Zero overhead when the detector is disabled.
-        _ld_enabled = False
-        if hasattr(self, '_ensure_loop_detector'):
-            from . import loop_detection as _loop_detection
-            _ld_history, _ld_config = self._ensure_loop_detector()
-            if _ld_config.enabled:
-                _ld_enabled = True
-                _loop_detection.record_tool_call(
-                    _ld_history, function_name, arguments, _ld_config
-                )
-                _verdict = _loop_detection.detect_tool_loop(
-                    _ld_history, function_name, arguments, _ld_config
-                )
-                if _verdict.get("stuck"):
-                    if _verdict.get("level") == "critical":
-                        return {
-                            "error": _verdict.get("message", "loop detected"),
-                            "loop_blocked": True,
-                        }
-                    elif not getattr(self, '_loop_warned_this_turn', False):
-                        self._loop_warned_this_turn = True
-                        self._pending_self_correction = (
-                            f"[System: repeated {_verdict.get('detector')} detected. "
-                            f"Try a different approach. {_verdict.get('message', '')}]"
-                        )
-
-        def _record_async_loop_outcome(_result):
-            # Back-fill the result hash so the result-aware detector can tell a
-            # genuine stall (identical output) from legitimate polling (changing
-            # output) on the async path too. Without this, records keep
-            # result_hash=None and no-progress detection never accumulates a
-            # streak, so async poll-loops go undetected. Mirrors the sync
-            # back-fill in tool_execution.py.
-            if _ld_enabled:
-                _loop_detection.record_tool_outcome(
-                    _ld_history, function_name, arguments, _result, _ld_config
-                )
-            return _result
+        # the review's own calls are not tracked and cannot recurse.
+        if not getattr(self, "_in_skill_review", False):
+            turn_tools = getattr(self, "_turn_tools_used", None)
+            if turn_tools is None:
+                self._turn_tools_used = []
+                turn_tools = self._turn_tools_used
+            turn_tools.append(function_name)
 
         # Enforce BEFORE_TOOL/AFTER_TOOL security hooks for every async caller,
         # mirroring the sync execute_tool path in tool_execution.py. Without
@@ -1462,12 +1208,10 @@ Write the complete compiled report:"""
                         result = f"{result}\n\n{extra_context}"
                     elif isinstance(result, dict):
                         result.setdefault("_additional_context", extra_context)
-            return _record_async_loop_outcome(result)
+            return result
 
-        return _record_async_loop_outcome(
-            await self._execute_tool_async_dispatch(
-                function_name, arguments, tool_call_id, tools_override
-            )
+        return await self._execute_tool_async_dispatch(
+            function_name, arguments, tool_call_id, tools_override
         )
 
     async def _execute_tool_async_dispatch(self, function_name: str, arguments: Dict[str, Any], tool_call_id: Optional[str] = None, tools_override: Optional[List] = None) -> Any:
@@ -1541,14 +1285,11 @@ Write the complete compiled report:"""
                 
                 # Check if result is an error that should be retried
                 if isinstance(result, dict) and result.get("error"):
-                    # Skip retry for non-retryable errors (approval, permission, etc.).
-                    # `retryable is False` covers async tool timeouts, whose executor
-                    # work cannot be cancelled — retrying would duplicate side effects.
+                    # Skip retry for non-retryable errors (approval, permission, etc.)
                     if (result.get("approval_denied") or 
                         result.get("permission_denied") or 
                         result.get("approval_error") or
-                        result.get("circuit_open") or
-                        result.get("retryable") is False):
+                        result.get("circuit_open")):
                         return result
                     
                     # Determine error type for retry policy
@@ -1628,22 +1369,11 @@ Write the complete compiled report:"""
                     return policy_result  # Error dict
                 _, arguments = policy_result
 
-            # Try to find the function in the override tools list first, then agent's tools list.
-            # Resolve by BaseTool/FunctionTool ``.name`` (instances like BrowserBaseTool or
-            # aliased decorated tools), plain callable ``__name__``, or class name so async
-            # dispatch matches the robust sync resolution in _execute_tool_impl.
+            # Try to find the function in the override tools list first, then agent's tools list
             func = None
             tools_to_search = tools_override if tools_override is not None else self.tools
-            from ..tools.base import BaseTool
             for tool in tools_to_search:
-                if isinstance(tool, BaseTool) and getattr(tool, 'name', None) == function_name:
-                    func = tool
-                    break
-                if hasattr(tool, 'name') and getattr(tool, 'name', None) == function_name:
-                    func = tool
-                    break
-                if (callable(tool) and getattr(tool, '__name__', '') == function_name) or \
-                   (inspect.isclass(tool) and tool.__name__ == function_name):
+                if (callable(tool) and getattr(tool, '__name__', '') == function_name):
                     func = tool
                     break
             
@@ -1651,85 +1381,17 @@ Write the complete compiled report:"""
                 logging.error(f"Function {function_name} not found in tools")
                 return {"error": f"Function {function_name} not found in tools"}
 
-            # Activate the tool-progress channel so tools running under the async
-            # path can stream incremental output (emit_tool_progress) and the
-            # built-in todo tool can publish live updates (emit_todo_update),
-            # mirroring the sync execute_tool path. Zero overhead when no stream
-            # callbacks are registered — the sink stays None and the contextvar
-            # is set to None (a no-op for emitters).
-            _progress_sink = None
-            _stream_emitter = self._get_existing_stream_emitter() if hasattr(self, "_get_existing_stream_emitter") else None
-            if _stream_emitter is not None and _stream_emitter.has_callbacks:
-                def _progress_sink(_event, _emitter=_stream_emitter):  # noqa: ANN001 — StreamEvent forwarder
-                    _event.tool_call = {"name": function_name, "id": tool_call_id}
-                    _event.agent_id = self.name
-                    _emitter.emit(_event)
-
-            from ..streaming.events import tool_progress_channel
-
             try:
-                # BaseTool instances (plugin system, e.g. BrowserBaseTool) are not
-                # directly callable — dispatch to their .run() method like the sync path.
-                call_target = func.run if isinstance(func, BaseTool) else func
-                try:
-                    from .durable import get_durable_idempotency_key
-
-                    durable_key = get_durable_idempotency_key()
-                except ImportError:
-                    durable_key = None
-                call_arguments = arguments
-                if durable_key:
-                    try:
-                        parameters = inspect.signature(call_target).parameters.values()
-                    except (TypeError, ValueError):
-                        parameters = ()
-                    if any(
-                        parameter.name == "idempotency_key"
-                        or parameter.kind == inspect.Parameter.VAR_KEYWORD
-                        for parameter in parameters
-                    ):
-                        call_arguments = dict(arguments)
-                        call_arguments["idempotency_key"] = durable_key
-
-                async def _invoke():
-                    # Set the tool-progress channel BEFORE dispatch so the sink
-                    # propagates into the executor thread via contextvars, mirroring
-                    # the sync execute_tool path.
-                    if inspect.iscoroutinefunction(call_target):
-                        logging.debug(f"Executing async function: {function_name}")
-                        with tool_progress_channel(_progress_sink):
-                            return await call_target(**call_arguments)
+                if inspect.iscoroutinefunction(func):
+                    logging.debug(f"Executing async function: {function_name}")
+                    result = await func(**arguments)
+                else:
                     logging.debug(f"Executing sync function in executor: {function_name}")
                     loop = asyncio.get_running_loop()
                     from ..trace.context_events import copy_context_to_callable
-                    with tool_progress_channel(_progress_sink):
-                        return await loop.run_in_executor(
-                            None, copy_context_to_callable(lambda: call_target(**call_arguments))
-                        )
-
-                # Apply the per-agent tool timeout (ToolConfig.timeout) so the async
-                # path matches the sync path in tool_execution.py. asyncio.wait_for
-                # cannot kill a stuck sync tool running in the executor (same caveat
-                # the sync path has with future.cancel()), but it stops the awaiting
-                # coroutine from hanging forever, which is the actual defect.
-                tool_timeout = getattr(self, '_tool_timeout', None)
-                if tool_timeout and tool_timeout > 0:
-                    try:
-                        result = await asyncio.wait_for(_invoke(), timeout=tool_timeout)
-                    except asyncio.TimeoutError:
-                        logging.warning(f"Tool {function_name} timed out after {tool_timeout}s")
-                        # Mark as non-retryable: asyncio.wait_for cannot cancel a sync
-                        # tool already running in the executor, so retrying would launch
-                        # a duplicate invocation while the original keeps executing —
-                        # duplicating DB writes / API calls / file mutations. Surface the
-                        # timeout once instead of re-running an uncancellable side effect.
-                        return {
-                            "error": f"Tool timed out after {tool_timeout}s",
-                            "timeout": True,
-                            "retryable": False,
-                        }
-                else:
-                    result = await _invoke()
+                    result = await loop.run_in_executor(
+                        None, copy_context_to_callable(lambda: func(**arguments))
+                    )
                 
                 # Ensure result is JSON serializable
                 logging.debug(f"Raw result from tool: {result}")
@@ -1812,194 +1474,250 @@ Write the complete compiled report:"""
                 
         should_start = False
         with _server_lock:
-            # Initialize port-specific collections if needed (once per port)
+            # Initialize port-specific collections if needed
             if port not in _registered_agents:
                 _registered_agents[port] = {}
 
-            # Initialize shared FastAPI app if not already created for this port
-            if _shared_apps.get(port) is None:
-                _shared_apps[port] = FastAPI(
-                    title=f"PraisonAI Agents API (Port {port})",
-                    description="API for interacting with PraisonAI Agents"
-                )
-
-                # Add a root endpoint with a welcome message
-                @_shared_apps[port].get("/")
-                async def root():
-                    return {
-                        "message": f"Welcome to PraisonAI Agents API on port {port}. See /docs for usage.",
-                        "endpoints": list(_registered_agents[port].keys())
-                    }
-
-                # Add healthcheck endpoint
-                @_shared_apps[port].get("/health")
-                async def healthcheck():
-                    return {
-                        "status": "ok",
-                        "endpoints": list(_registered_agents[port].keys())
-                    }
-
-            # The path registration below must run on EVERY call, not just when the
-            # port is new, so multiple agents can share a single port.
-
-            # Normalize path to ensure it starts with /
-            if not path.startswith('/'):
-                path = f'/{path}'
-
-            # Check if path is already registered for this port
-            if path in _registered_agents[port]:
-                logging.warning(f"Path '{path}' is already registered on port {port}. Please use a different path.")
-                print(f"⚠️ Warning: Path '{path}' is already registered on port {port}.")
-                # Use a modified path to avoid conflicts
-                original_path = path
-                path = f"{path}_{self.agent_id[:6]}"
-                logging.warning(f"Using '{path}' instead of '{original_path}'")
-                print(f"🔄 Using '{path}' instead")
-
-            # Register the agent to this path
-            _registered_agents[port][path] = self.agent_id
-
-            # Define the endpoint handler
-            @_shared_apps[port].post(path)
-            async def handle_agent_query(request: Request, query_data: Optional[AgentQuery] = None):
-                # Handle both direct JSON with query field and form data
-                if query_data is None:
-                    try:
-                        request_data = await request.json()
-                        if "query" not in request_data:
-                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
-                        query = request_data["query"]
-                    except Exception:
-                        # Fallback to form data or query params
-                        form_data = await request.form()
-                        if "query" in form_data:
-                            query = form_data["query"]
-                        else:
-                            raise HTTPException(status_code=400, detail="Missing 'query' field in request")
-                else:
-                    query = query_data.query
-
-                try:
-                    # Use async version if available, otherwise use sync version
-                    if asyncio.iscoroutinefunction(self.chat):
-                        response = await self.achat(query, task_name=None, task_description=None, task_id=None)
-                    else:
-                        # Run sync function in a thread to avoid blocking
-                        loop = asyncio.get_running_loop()
-                        response = await loop.run_in_executor(None, lambda p=query: self.chat(p))
-
-                    return {"response": response}
-                except Exception as e:
-                    logging.error(f"Error processing query: {str(e)}", exc_info=True)
-                    return JSONResponse(
-                        status_code=500,
-                        content={"error": f"Error processing query: {str(e)}"}
+                # Initialize shared FastAPI app if not already created for this port
+                if _shared_apps.get(port) is None:
+                    _shared_apps[port] = FastAPI(
+                        title=f"PraisonAI Agents API (Port {port})",
+                        description="API for interacting with PraisonAI Agents"
                     )
 
-            # Invalidate the cached OpenAPI schema so routes registered by later
-            # shared-port launch() calls still show up in /openapi.json and /docs.
-            # FastAPI caches app.openapi_schema on first access and does not
-            # regenerate it when new routes are added afterwards.
-            _shared_apps[port].openapi_schema = None
+                    # Add a root endpoint with a welcome message
+                    @_shared_apps[port].get("/")
+                    async def root():
+                        return {
+                            "message": f"Welcome to PraisonAI Agents API on port {port}. See /docs for usage.",
+                            "endpoints": list(_registered_agents[port].keys())
+                        }
 
-            print(f"🚀 Agent '{self.name}' available at http://{host}:{port}")
+                    # Add healthcheck endpoint
+                    @_shared_apps[port].get("/health")
+                    async def healthcheck():
+                        return {
+                            "status": "ok",
+                            "endpoints": list(_registered_agents[port].keys())
+                        }
 
-            # Check and mark server as started atomically to prevent race conditions
-            should_start = not _server_started.get(port, False)
-            if should_start:
-                _server_started[port] = True
+                # Normalize path to ensure it starts with /
+                if not path.startswith('/'):
+                    path = f'/{path}'
 
-        # Server start/wait outside the lock to avoid holding it during sleep
-        if should_start:
-            # Start the server in a separate thread
-            def run_server():
-                try:
-                    print(f"✅ FastAPI server started at http://{host}:{port}")
-                    print(f"📚 API documentation available at http://{host}:{port}/docs")
-                    print(f"🔌 Available endpoints: {', '.join(list(_registered_agents[port].keys()))}")
-                    uvicorn.run(_shared_apps[port], host=host, port=port, log_level="debug" if debug else "info")
-                except Exception as e:
-                    logging.error(f"Error starting server: {str(e)}", exc_info=True)
-                    print(f"❌ Error starting server: {str(e)}")
+                # Check if path is already registered for this port
+                if path in _registered_agents[port]:
+                    logging.warning(f"Path '{path}' is already registered on port {port}. Please use a different path.")
+                    print(f"⚠️ Warning: Path '{path}' is already registered on port {port}.")
+                    # Use a modified path to avoid conflicts
+                    original_path = path
+                    path = f"{path}_{self.agent_id[:6]}"
+                    logging.warning(f"Using '{path}' instead of '{original_path}'")
+                    print(f"🔄 Using '{path}' instead")
 
-            # Run server in a background thread
-            server_thread = threading.Thread(target=run_server, daemon=True)
-            server_thread.start()
+                # Register the agent to this path
+                _registered_agents[port][path] = self.agent_id
 
-            # Wait for a moment to allow the server to start and register endpoints
-            self._safe_sleep(0.5)
-        else:
-            # If server is already running, wait a moment to make sure the endpoint is registered
-            self._safe_sleep(0.1)
-            print(f"🔌 Available endpoints on port {port}: {', '.join(list(_registered_agents[port].keys()))}")
+                # Define the endpoint handler
+                @_shared_apps[port].post(path)
+                async def handle_agent_query(request: Request, query_data: Optional[AgentQuery] = None):
+                    # Handle both direct JSON with query field and form data
+                    if query_data is None:
+                        try:
+                            request_data = await request.json()
+                            if "query" not in request_data:
+                                raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                            query = request_data["query"]
+                        except Exception:
+                            # Fallback to form data or query params
+                            form_data = await request.form()
+                            if "query" in form_data:
+                                query = form_data["query"]
+                            else:
+                                raise HTTPException(status_code=400, detail="Missing 'query' field in request")
+                    else:
+                        query = query_data.query
 
-        # Get the stack frame to check if this is the last launch() call in the script
-        import inspect
-        stack = inspect.stack()
-
-        # If this is called from a Python script (not interactive), try to detect if it's the last launch call
-        if len(stack) > 1 and stack[1].filename.endswith('.py'):
-            caller_frame = stack[1]
-            caller_line = caller_frame.lineno
-
-            try:
-                # Read the file to check if there are more launch calls after this one
-                with open(caller_frame.filename, 'r') as f:
-                    lines = f.readlines()
-
-                # Check if there are more launch() calls after the current line
-                has_more_launches = False
-                for line_content in lines[caller_line:]: # renamed line to line_content
-                    if '.launch(' in line_content and not line_content.strip().startswith('#'):
-                        has_more_launches = True
-                        break
-
-                # If this is the last launch call, block the main thread
-                if not has_more_launches:
                     try:
-                        print("\nAll agents registered for HTTP mode. Press Ctrl+C to stop the servers.")
+                        # Use async version if available, otherwise use sync version
+                        if asyncio.iscoroutinefunction(self.chat):
+                            response = await self.achat(query, task_name=None, task_description=None, task_id=None)
+                        else:
+                            # Run sync function in a thread to avoid blocking
+                            loop = asyncio.get_running_loop()
+                            response = await loop.run_in_executor(None, lambda p=query: self.chat(p))
+
+                        return {"response": response}
+                    except Exception as e:
+                        logging.error(f"Error processing query: {str(e)}", exc_info=True)
+                        return JSONResponse(
+                            status_code=500,
+                            content={"error": f"Error processing query: {str(e)}"}
+                        )
+
+                print(f"🚀 Agent '{self.name}' available at http://{host}:{port}")
+
+                # Check and mark server as started atomically to prevent race conditions
+                should_start = not _server_started.get(port, False)
+                if should_start:
+                    _server_started[port] = True
+
+            # Server start/wait outside the lock to avoid holding it during sleep  
+            if should_start:
+                # Start the server in a separate thread
+                def run_server():
+                    try:
+                        print(f"✅ FastAPI server started at http://{host}:{port}")
+                        print(f"📚 API documentation available at http://{host}:{port}/docs")
+                        print(f"🔌 Available endpoints: {', '.join(list(_registered_agents[port].keys()))}")
+                        uvicorn.run(_shared_apps[port], host=host, port=port, log_level="debug" if debug else "info")
+                    except Exception as e:
+                        logging.error(f"Error starting server: {str(e)}", exc_info=True)
+                        print(f"❌ Error starting server: {str(e)}")
+
+                # Run server in a background thread
+                server_thread = threading.Thread(target=run_server, daemon=True)
+                server_thread.start()
+
+                # Wait for a moment to allow the server to start and register endpoints
+                self._safe_sleep(0.5)
+            else:
+                # If server is already running, wait a moment to make sure the endpoint is registered
+                self._safe_sleep(0.1)
+                print(f"🔌 Available endpoints on port {port}: {', '.join(list(_registered_agents[port].keys()))}")
+            
+            # Get the stack frame to check if this is the last launch() call in the script
+            import inspect
+            stack = inspect.stack()
+            
+            # If this is called from a Python script (not interactive), try to detect if it's the last launch call
+            if len(stack) > 1 and stack[1].filename.endswith('.py'):
+                caller_frame = stack[1]
+                caller_line = caller_frame.lineno
+                
+                try:
+                    # Read the file to check if there are more launch calls after this one
+                    with open(caller_frame.filename, 'r') as f:
+                        lines = f.readlines()
+                    
+                    # Check if there are more launch() calls after the current line
+                    has_more_launches = False
+                    for line_content in lines[caller_line:]: # renamed line to line_content
+                        if '.launch(' in line_content and not line_content.strip().startswith('#'):
+                            has_more_launches = True
+                            break
+                    
+                    # If this is the last launch call, block the main thread
+                    if not has_more_launches:
+                        try:
+                            print("\nAll agents registered for HTTP mode. Press Ctrl+C to stop the servers.")
+                            while True:
+                                self._safe_sleep(1)
+                        except KeyboardInterrupt:
+                            print("\nServers stopped")
+                except Exception as e:
+                    # If something goes wrong with detection, block anyway to be safe
+                    logging.error(f"Error in launch detection: {e}")
+                    try:
+                        print("\nKeeping HTTP servers alive. Press Ctrl+C to stop.")
                         while True:
                             self._safe_sleep(1)
                     except KeyboardInterrupt:
                         print("\nServers stopped")
-            except Exception as e:
-                # If something goes wrong with detection, block anyway to be safe
-                logging.error(f"Error in launch detection: {e}")
-                try:
-                    print("\nKeeping HTTP servers alive. Press Ctrl+C to stop.")
-                    while True:
-                        self._safe_sleep(1)
-                except KeyboardInterrupt:
-                    print("\nServers stopped")
-        return None
+            return None
 
     def _launch_mcp_server(self, path: str, port: int, host: str, debug: bool):
         """
-        Launch this single agent as an MCP server.
-
-        Delegates to the ``praisonai-mcp`` agent adapter via ``serve_agents([self])``
-        so that ``Agent.launch(protocol="mcp")`` and
-        ``PraisonAIAgents.launch(protocol="mcp")`` share one code path and one
-        vocabulary (publishing ``ask_{agent_name}`` + ``list_agents``). The mcp
-        package is an optional dependency imported lazily here so core keeps no
-        hard dependency on it.
+        Launch MCP server (internal implementation).
+        
+        NOTE: This implementation will be moved to wrapper layer in future version.
+        For now, it maintains backward compatibility while following lazy import patterns.
         """
+        # For now, delegate to the existing MCP implementation 
+        # This will be extracted to a proper adapter in the future
         try:
-            from praisonai_mcp import serve_agents
+            import uvicorn
+            from mcp.server.fastmcp import FastMCP
+            from mcp.server.sse import SseServerTransport
+            from starlette.applications import Starlette
+            from starlette.requests import Request
+            from starlette.routing import Mount, Route
+            import threading
+            import time
+            import asyncio
+            
+            mcp_server_instance_name = f"{self.name}_mcp_server" if self.name else "agent_mcp_server"
+            mcp = FastMCP(mcp_server_instance_name)
 
-            # Keep the call inside the ImportError guard: serve_agents() lazily
-            # imports its transport backend, so a package that is installed
-            # without its optional transport extras surfaces the missing
-            # dependency here rather than at the import line above. Catching it
-            # in the same place yields one actionable install message instead of
-            # an uncaught traceback.
-            return serve_agents([self], host=host, port=port)
-        except ImportError:
-            _get_display_functions()['display_error'](
-                "MCP serving requires the 'praisonai-mcp' package."
+            # Determine the MCP tool name based on self.name
+            actual_mcp_tool_name = f"execute_{self.name.lower().replace(' ', '_').replace('-', '_')}_task" if self.name else "execute_task"
+
+            @mcp.tool(name=actual_mcp_tool_name)
+            async def execute_agent_task(prompt: str) -> str:
+                """Executes the agent's primary task with the given prompt."""
+                try:
+                    if hasattr(self, 'achat') and asyncio.iscoroutinefunction(self.achat):
+                        response = await self.achat(prompt, tools=self.tools, task_name=None, task_description=None, task_id=None)
+                    elif hasattr(self, 'chat'):
+                        from ..trace.context_events import copy_context_to_callable
+                        loop = asyncio.get_event_loop()
+                        response = await loop.run_in_executor(None, copy_context_to_callable(lambda p=prompt: self.chat(p, tools=self.tools)))
+                    else:
+                        return f"Error: Agent {self.name} misconfigured for MCP."
+                    return response if response is not None else "Agent returned no response."
+                except Exception as e:
+                    return f"Error executing task: {str(e)}"
+
+            # Create and run MCP server using the low-level SSE transport
+            # pattern (FastMCP has no create_app(); this mirrors the working
+            # implementation in praisonaiagents/mcp/mcp_server.py).
+            base_path = (path or "/mcp").rstrip("/") or "/mcp"
+            if not base_path.startswith("/"):
+                base_path = f"/{base_path}"
+            sse_path = f"{base_path}/sse"
+            messages_path = f"{base_path}/messages/"
+            transport = SseServerTransport(messages_path)
+
+            async def handle_sse(request: Request):
+                async with transport.connect_sse(
+                    request.scope, request.receive, request._send
+                ) as (read_stream, write_stream):
+                    await mcp._mcp_server.run(
+                        read_stream,
+                        write_stream,
+                        mcp._mcp_server.create_initialization_options()
+                    )
+
+            starlette_app = Starlette(
+                routes=[
+                    Route(sse_path, endpoint=handle_sse),
+                    Mount(messages_path, app=transport.handle_post_message),
+                ]
             )
-            print("\nTo add MCP capabilities, install: pip install praisonai-mcp")
+
+            def run_mcp_server():
+                try:
+                    uvicorn.run(starlette_app, host=host, port=port, log_level="debug" if debug else "info")
+                except Exception as e:
+                    logging.error(f"Error starting MCP server: {str(e)}", exc_info=True)
+
+            server_thread = threading.Thread(target=run_mcp_server, daemon=True)
+            server_thread.start()
+            self._safe_sleep(0.5)
+
+            try:
+                print("\nKeeping MCP server alive. Press Ctrl+C to stop.")
+                while True:
+                    self._safe_sleep(1)
+            except KeyboardInterrupt:
+                print("\nMCP Server stopped")
             return None
+            
+        except ImportError as e:
+            missing_module = str(e).split("No module named '")[-1].rstrip("'")
+            _get_display_functions()['display_error'](f"Missing dependency: {missing_module}. Required for MCP mode.")
+            print(f"\nTo add MCP capabilities, install: pip install {missing_module}")
+            return None 
 
     async def _emit_retry_hook_async(self, tool_name, attempt, delay_ms, error, max_attempts, error_type):
         """Emit ON_RETRY hook event (async version).

src/praisonai-agents/praisonaiagents/agent/handoff.py

@@ -14,9 +14,9 @@ from typing import Optional, Any, Callable, Dict, List, Union, TYPE_CHECKING, Li
 from dataclasses import dataclass, field
 from enum import Enum
 import inspect
+import logging
 from praisonaiagents._logging import get_logger
 import asyncio
-import contextvars
 import threading
 import time
 import json
@@ -163,52 +163,33 @@ from ..errors import (
     HandoffValidationError
 )
 
-# Per-task/per-thread storage for tracking handoff chains.
-#
-# ``contextvars.ContextVar`` isolates the chain per :class:`asyncio.Task`
-# (and per OS thread), unlike ``threading.local()`` which shares one list
-# across every coroutine running on the same event-loop thread. Concurrent
-# async handoffs (``asyncio.gather``, a server handling parallel requests, or
-# any ``max_concurrent`` workflow) would otherwise push/pop into the same list
-# and corrupt each other's cycle/depth state. Combined with the copy-on-write
-# push/pop below, this fully isolates sibling handoff tasks (e.g. those spawned
-# by ``parallel_handoffs`` via ``asyncio.gather``).
-_handoff_chain_var: "contextvars.ContextVar[Optional[List[str]]]" = contextvars.ContextVar(
-    "handoff_chain", default=None
-)
+# Thread-local storage for tracking handoff chains
+_handoff_context = threading.local()
 
 def _get_handoff_chain() -> List[str]:
-    """Get current handoff chain for this task/thread."""
-    chain = _handoff_chain_var.get()
-    if chain is None:
-        chain = []
-        _handoff_chain_var.set(chain)
-    return chain
+    """Get current handoff chain from thread-local storage."""
+    if not hasattr(_handoff_context, 'chain'):
+        _handoff_context.chain = []
+    return _handoff_context.chain
 
 def _get_handoff_depth() -> int:
     """Get current handoff depth."""
     return len(_get_handoff_chain())
 
 def _push_handoff(agent_name: str) -> None:
-    """Push agent to handoff chain.
-
-    Uses copy-on-write so a push made inside a child task does not leak back
-    into the parent task's chain once the child completes.
-    """
-    chain = list(_get_handoff_chain())
+    """Push agent to handoff chain."""
+    chain = _get_handoff_chain()
     chain.append(agent_name)
-    _handoff_chain_var.set(chain)
 
 def _pop_handoff() -> Optional[str]:
     """Pop agent from handoff chain."""
-    chain = list(_get_handoff_chain())
-    popped = chain.pop() if chain else None
-    _handoff_chain_var.set(chain)
-    return popped
+    chain = _get_handoff_chain()
+    return chain.pop() if chain else None
 
 def _clear_handoff_chain() -> None:
     """Clear the handoff chain."""
-    _handoff_chain_var.set([])
+    if hasattr(_handoff_context, 'chain'):
+        _handoff_context.chain = []
 
 @dataclass
 class HandoffInputData:
@@ -308,14 +289,12 @@ class Handoff:
     - Cycle detection and depth limiting
     - Configurable context policies
     """
-
-    # Class-level lock guarding lazy creation of each instance's async
-    # semaphore. The semaphore itself is per-instance (so every Handoff
-    # enforces its own max_concurrent), but the brief init critical section is
-    # only ever touched under this shared threading.Lock, which keeps
-    # double-checked lazy creation thread-safe without a per-instance lock.
-    _semaphore_lock: threading.Lock = threading.Lock()
-
+    
+    # Class-level semaphore for concurrency control
+    _semaphore: Optional[asyncio.Semaphore] = None
+    _sync_semaphore: Optional[threading.Semaphore] = None
+    _semaphore_lock: threading.Lock = threading.Lock()  # Lock for semaphore initialization
+    
     def __init__(
         self,
         agent: 'Agent',
@@ -346,40 +325,10 @@ class Handoff:
         self.input_type = input_type
         self.input_filter = input_filter
         self.config = config or HandoffConfig()
-
-        # Instance-level concurrency control. Each Handoff enforces its own
-        # max_concurrent instead of sharing one process-wide semaphore, so
-        # different handoffs don't silently override each other's limits based
-        # on execution order. The async semaphore is created lazily (and
-        # recreated if bound to a stale event loop) since it binds to the
-        # running loop on first use.
-        self._semaphore: Optional[asyncio.Semaphore] = None
-        self._semaphore_loop: Optional[asyncio.AbstractEventLoop] = None
         
         # Override config callback if on_handoff provided directly
         if on_handoff and not self.config.on_handoff:
             self.config.on_handoff = on_handoff
-
-    def _get_semaphore(self) -> Optional[asyncio.Semaphore]:
-        """Return this handoff's async semaphore, bound to the current loop.
-
-        Returns None when concurrency limiting is disabled (max_concurrent <= 0).
-        The semaphore is created lazily and recreated if the running event loop
-        differs from the one it was originally bound to, so a process that calls
-        asyncio.run(...) more than once doesn't crash with a "bound to a
-        different event loop" RuntimeError.
-        """
-        if self.config.max_concurrent <= 0:
-            return None
-        try:
-            current_loop = asyncio.get_event_loop()
-        except RuntimeError:
-            current_loop = None
-        with self._semaphore_lock:
-            if self._semaphore is None or self._semaphore_loop is not current_loop:
-                self._semaphore = asyncio.Semaphore(self.config.max_concurrent)
-                self._semaphore_loop = current_loop
-            return self._semaphore
         
     @property
     def tool_name(self) -> str:
@@ -648,15 +597,13 @@ class Handoff:
         """
         start_time = time.time()
         kwargs = context or {}
-        pushed = False
         
         try:
-            # Safety checks (may raise before anything is pushed for this call)
+            # Safety checks
             self._check_safety(source_agent)
             
             # Track handoff chain
             _push_handoff(source_agent.name)
-            pushed = True
             
             # Execute on_handoff callback
             self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -732,8 +679,7 @@ class Handoff:
             logger.error(f"Handoff error: {e}")
             return result
         finally:
-            if pushed:
-                _pop_handoff()
+            _pop_handoff()
     
     async def execute_async(
         self,
@@ -752,19 +698,20 @@ class Handoff:
         Returns:
             HandoffResult with response or error
         """
-        # Per-instance semaphore, bound to the current event loop
-        semaphore = self._get_semaphore()
+        # Initialize semaphore if needed (thread-safe)
+        if self.config.max_concurrent > 0 and Handoff._semaphore is None:
+            with Handoff._semaphore_lock:  # Thread-safe initialization
+                if Handoff._semaphore is None:  # Double-check after acquiring lock
+                    Handoff._semaphore = asyncio.Semaphore(self.config.max_concurrent)
         
         start_time = time.time()
         kwargs = context or {}
         
         async def _execute():
-            pushed = False
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -813,12 +760,11 @@ class Handoff:
                 
                 return result
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         try:
-            if semaphore is not None:
-                async with semaphore:
+            if self.config.max_concurrent > 0 and Handoff._semaphore:
+                async with Handoff._semaphore:
                     if self.config.timeout_seconds > 0:
                         result = await asyncio.wait_for(
                             _execute(),
@@ -882,15 +828,13 @@ class Handoff:
         def handoff_tool(**kwargs):
             """Execute the handoff to the target agent."""
             start_time = time.time()
-            pushed = False
             
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 
                 # Track handoff chain
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute on_handoff callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -976,8 +920,7 @@ class Handoff:
                 self._execute_callback(self.config.on_error, source_agent, kwargs, result)
                 return f"Error during handoff to {self.agent.name}: {str(e)}"
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         # Set function metadata for tool definition generation
         handoff_tool.__name__ = self.tool_name
@@ -1228,13 +1171,6 @@ async def parallel_handoffs(
     semaphore = asyncio.Semaphore(effective_max_concurrent) if effective_max_concurrent > 0 else None
     
     async def _run_one(agent, prompt):
-        # Each gathered task shares a copied context, but a copied ContextVar
-        # binding still points at the *same* parent list object. Rebind to a
-        # fresh, per-task copy so sibling handoffs cannot corrupt each other's
-        # cycle/depth tracking when parallel_handoffs runs inside a non-empty
-        # parent handoff chain.
-        _handoff_chain_var.set(list(_handoff_chain_var.get() or []))
-
         async def _do_handoff():
             try:
                 return await source.handoff_to_async(agent, prompt, config=config)
@@ -1455,15 +1391,13 @@ class TypedHandoff(Handoff, Generic[T]):
         
         start_time = time.time()
         kwargs = context or {}
-        pushed = False
         
         try:
-            # Safety checks (may raise before anything is pushed for this call)
+            # Safety checks
             self._check_safety(source_agent)
             
             # Track handoff chain
             _push_handoff(source_agent.name)
-            pushed = True
             
             # Execute on_handoff callback
             self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -1536,8 +1470,7 @@ class TypedHandoff(Handoff, Generic[T]):
             logger.error(f"Typed handoff error: {e}")
             return result
         finally:
-            if pushed:
-                _pop_handoff()
+            _pop_handoff()
     
     async def execute_async(
         self,
@@ -1564,19 +1497,20 @@ class TypedHandoff(Handoff, Generic[T]):
         if isinstance(payload, str):
             return await super().execute_async(source_agent, payload, context)
         
-        # Per-instance semaphore, bound to the current event loop
-        semaphore = self._get_semaphore()
+        # Initialize semaphore if needed (thread-safe)
+        if self.config.max_concurrent > 0 and Handoff._semaphore is None:
+            with Handoff._semaphore_lock:
+                if Handoff._semaphore is None:
+                    Handoff._semaphore = asyncio.Semaphore(self.config.max_concurrent)
         
         start_time = time.time()
         kwargs = context or {}
         
         async def _execute():
-            pushed = False
             try:
-                # Safety checks (may raise before anything is pushed for this call)
+                # Safety checks
                 self._check_safety(source_agent)
                 _push_handoff(source_agent.name)
-                pushed = True
                 
                 # Execute callback
                 self._execute_callback(self.config.on_handoff or self.on_handoff, source_agent, kwargs)
@@ -1624,12 +1558,11 @@ class TypedHandoff(Handoff, Generic[T]):
                     handoff_depth=_get_handoff_depth(),
                 )
             finally:
-                if pushed:
-                    _pop_handoff()
+                _pop_handoff()
         
         try:
-            if semaphore is not None:
-                async with semaphore:
+            if self.config.max_concurrent > 0 and Handoff._semaphore:
+                async with Handoff._semaphore:
                     if self.config.timeout_seconds > 0:
                         result = await asyncio.wait_for(
                             _execute(),

src/praisonai-agents/praisonaiagents/agent/heartbeat.py

@@ -13,6 +13,7 @@ Usage::
 """
 
 import asyncio
+import logging
 from praisonaiagents._logging import get_logger
 import threading
 import time

src/praisonai-agents/praisonaiagents/agent/interrupt.py

@@ -6,7 +6,7 @@ operations. Follows protocol-driven design with zero overhead when not used.
 """
 
 import threading
-from typing import Optional, Protocol, Set
+from typing import Optional, Protocol
 from dataclasses import dataclass, field
 
 __all__ = ["InterruptControllerProtocol", "InterruptController"]
@@ -57,10 +57,6 @@ class InterruptController:
     
     _flag: threading.Event = field(default_factory=threading.Event, init=False, repr=False)
     _reason: Optional[str] = field(default=None, init=False)
-    _active_turns: Set[int] = field(default_factory=set, init=False, repr=False)
-    _cancelled_turns: Set[int] = field(default_factory=set, init=False, repr=False)
-    _next_turn_id: int = field(default=0, init=False, repr=False)
-    _pending_turn_cancel: bool = field(default=False, init=False, repr=False)
     _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
 
     def request(self, reason: str = "user") -> None:
@@ -73,40 +69,12 @@ class InterruptController:
             if not self._flag.is_set():
                 self._reason = reason
                 self._flag.set()
-            if self._active_turns:
-                self._cancelled_turns.update(self._active_turns)
-            else:
-                self._pending_turn_cancel = True
-
-    def _begin_turn(self) -> int:
-        """Register an Agent turn and consume any request made while idle."""
-        with self._lock:
-            self._next_turn_id += 1
-            turn_id = self._next_turn_id
-            self._active_turns.add(turn_id)
-            if self._pending_turn_cancel:
-                self._cancelled_turns.add(turn_id)
-                self._pending_turn_cancel = False
-            return turn_id
-
-    def _turn_is_cancelled(self, turn_id: int) -> bool:
-        """Return whether a registered turn was targeted by a request."""
-        with self._lock:
-            return turn_id in self._cancelled_turns
-
-    def _end_turn(self, turn_id: int) -> None:
-        """Unregister a turn so its request cannot affect a future turn."""
-        with self._lock:
-            self._active_turns.discard(turn_id)
-            self._cancelled_turns.discard(turn_id)
 
     def clear(self) -> None:
         """Clear the cancellation request."""
         with self._lock:
             self._reason = None
             self._flag.clear()
-            self._pending_turn_cancel = False
-            self._cancelled_turns.clear()
 
     def is_set(self) -> bool:
         """Check if cancellation has been requested.

src/praisonai-agents/praisonaiagents/agent/loop_detection.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
 from praisonaiagents._logging import get_logger
 import time
 from dataclasses import dataclass, field
@@ -160,32 +161,6 @@ def record_tool_call(
     if len(history) > max_size:
         del history[: len(history) - max_size]
 
-def reset_matching_history(
-    history: List[ToolCallRecord],
-    tool_name: str,
-    args: Any,
-) -> int:
-    """Drop every record for this exact ``(tool_name, args)`` pair in-place.
-
-    Used when a critical loop is *explicitly approved* to continue: simply
-    popping the just-recorded call would leave the streak one below the
-    threshold, so the very next identical call would re-trigger the gate. By
-    removing the whole matching streak, an approved legitimate repeat gets a
-    fresh window (another full ``critical_threshold`` run) before it is flagged
-    again. Records for *other* tools/args are preserved, so concurrent activity
-    on the same agent is unaffected.
-
-    Returns the number of records removed.
-    """
-    args_hash = hash_tool_call(tool_name, args)
-    before = len(history)
-    history[:] = [
-        rec for rec in history
-        if not (rec.get("tool_name") == tool_name and rec.get("args_hash") == args_hash)
-    ]
-    return before - len(history)
-
-
 def record_tool_outcome(
     history: List[ToolCallRecord],
     tool_name: str,

src/praisonai-agents/praisonaiagents/agent/memory_mixin.py

@@ -9,18 +9,8 @@ for maintainability.
 import os
 import inspect
 import logging
-import contextvars
 from typing import Optional
 
-# Per-turn ownership of appended chat-history messages. Each chat()/achat() turn
-# runs in its own thread (sync) or task (async); both get an isolated copy of
-# this context var. The append helpers record every message THIS turn appends
-# into its own list, so a failing turn's rollback removes only its own messages
-# and never a concurrent turn's - even though all turns share one chat_history.
-_active_turn_owned: "contextvars.ContextVar[Optional[list]]" = contextvars.ContextVar(
-    "praisonai_active_turn_owned", default=None
-)
-
 # Shared lazy display helpers (cached, thread-safe; avoid circular imports)
 from ._lazy_display import _get_console, _get_live, _get_display_functions
 
@@ -67,11 +57,7 @@ class MemoryMixin:
             content: Message content
         """
         with self._history_lock:
-            msg = {"role": role, "content": content}
-            self.chat_history.append(msg)
-            owned = _active_turn_owned.get()
-            if owned is not None:
-                owned.append(msg)
+            self.chat_history.append({"role": role, "content": content})
 
     def _add_to_chat_history_if_not_duplicate(self, role, content) -> bool:
         """Thread-safe method to add messages to chat history only if not duplicate.
@@ -93,11 +79,7 @@ class MemoryMixin:
                 return False
             
             # Not a duplicate, add the message
-            msg = {"role": role, "content": content}
-            self.chat_history.append(msg)
-            owned = _active_turn_owned.get()
-            if owned is not None:
-                owned.append(msg)
+            self.chat_history.append({"role": role, "content": content})
             return True
 
     def _get_chat_history_length(self):
@@ -114,66 +96,6 @@ class MemoryMixin:
         with self._history_lock:
             self.chat_history = self.chat_history[:length]
 
-    def _begin_turn_tracking(self):
-        """Start recording the messages appended by the current turn.
-
-        Returns a token to reset the context var when the turn ends. Each turn
-        runs in its own thread (sync ``chat``) or task (async ``achat``), so the
-        context var copy is isolated per turn. Safe to call unconditionally; when
-        a turn opts in, its rollback removes only its own messages by identity.
-        """
-        return _active_turn_owned.set([])
-
-    def _end_turn_tracking(self, token):
-        """Stop recording for the current turn and drop its ownership list."""
-        try:
-            _active_turn_owned.reset(token)
-        except (ValueError, LookupError):
-            _active_turn_owned.set(None)
-
-    def _clear_turn_tracking(self):
-        """Drop any per-turn ownership list from a prior turn on this context.
-
-        Used at the start of an async turn (whose control flow has no single
-        wrapping ``finally``) so a stale list from a completed turn on the same
-        task cannot accumulate messages from unrelated turns.
-        """
-        _active_turn_owned.set(None)
-
-    def _rollback_chat_history_to(self, rollback_length):
-        """Thread-safe rollback that never clobbers a concurrent turn's messages.
-
-        A turn snapshots ``len(self.chat_history)`` before a multi-second LLM
-        call, then rolls back to that length on failure.
-
-        Ownership-safe path (default for ``chat``/``achat`` turns): when the turn
-        opted into per-turn tracking via ``_begin_turn_tracking()``, remove ONLY
-        the messages this turn actually appended, identified by object identity.
-        A concurrent turn that interleaved its own messages after this snapshot
-        keeps every one of them - the old positional ``del chat_history[n:]``
-        would have erased them and corrupted the transcript.
-
-        Positional fallback (untracked callers): remove the tail from
-        ``rollback_length`` onward, and only if the history actually grew that
-        far. Backward compatible for any path that does not track ownership.
-
-        Args:
-            rollback_length: History length to roll back to (this turn's snapshot).
-        """
-        owned = _active_turn_owned.get()
-        with self._history_lock:
-            if owned:
-                owned_ids = {id(m) for m in owned}
-                self.chat_history[:] = [
-                    m for m in self.chat_history if id(m) not in owned_ids
-                ]
-                owned.clear()
-                return
-
-            # Untracked turn (or nothing appended): safe positional rollback.
-            if len(self.chat_history) > rollback_length:
-                del self.chat_history[rollback_length:]
-
     def _cache_get(self, cache_dict, key):
         """Thread-safe LRU cache get operation.
         
@@ -318,25 +240,21 @@ class MemoryMixin:
             if hasattr(self._history_lock, 'is_async_context') and self._history_lock.is_async_context():
                 # Cannot use asyncio.Lock in sync context - use thread lock as fallback
                 import hashlib
-                import uuid
                 from datetime import datetime, timezone
                 with self._history_lock._lock._thread_lock:
                     if self._session_id is None:  # Double-check after acquiring lock
                         hour_str = datetime.now(timezone.utc).strftime("%Y%m%d%H")
                         agent_hash = hashlib.sha256((self.name or "agent").encode()).hexdigest()[:6]
-                        # per-instance suffix so same-named agents can never collide
-                        self._session_id = f"{hour_str}-{agent_hash}-{uuid.uuid4().hex[:8]}"
+                        self._session_id = f"{hour_str}-{agent_hash}"
             else:
                 # Use sync lock directly
                 import hashlib
-                import uuid
                 from datetime import datetime, timezone
                 with self._history_lock.lock():
                     if self._session_id is None:  # Double-check after acquiring lock
                         hour_str = datetime.now(timezone.utc).strftime("%Y%m%d%H")
                         agent_hash = hashlib.sha256((self.name or "agent").encode()).hexdigest()[:6]
-                        # per-instance suffix so same-named agents can never collide
-                        self._session_id = f"{hour_str}-{agent_hash}-{uuid.uuid4().hex[:8]}"
+                        self._session_id = f"{hour_str}-{agent_hash}"
         
         # Call db adapter's on_agent_start to get previous messages
         try:
@@ -513,28 +431,6 @@ class MemoryMixin:
             except Exception as e:
                 logging.warning(f"Failed to persist message to session store: {e}")
 
-    async def _apersist_message(
-        self,
-        role: str,
-        content: str,
-        tool_calls=None,
-        tool_call_id: Optional[str] = None,
-    ):
-        """Async wrapper for :meth:`_persist_message`.
-
-        The default JSON session store performs a file-locked, blocking
-        read-modify-write to disk on every turn. Calling ``_persist_message``
-        directly from ``_achat_impl`` would stall the entire event loop (other
-        agents, streaming, background tasks) for the duration of that I/O on
-        every user/assistant/tool turn. Offloading to a worker thread — the
-        same treatment ``_persist_compaction_checkpoint`` already gets — keeps
-        ``achat()`` non-blocking as documented.
-        """
-        import asyncio
-        await asyncio.to_thread(
-            self._persist_message, role, content, tool_calls, tool_call_id
-        )
-
     def _add_message_with_tool_fields(self, role, content, **tool_fields):
         """Add a message carrying tool fields, tolerating stores without them.
 

src/praisonai-agents/praisonaiagents/agent/message_queue.py

@@ -8,6 +8,7 @@ Thread-safe implementation for concurrent access.
 import threading
 import heapq
 import time
+import logging
 from praisonaiagents._logging import get_logger
 from typing import Optional, Any, List, Tuple
 from dataclasses import dataclass, field

src/praisonai-agents/praisonaiagents/agent/prompt_cache.py

@@ -1,138 +0,0 @@
-"""Prompt-cache-stability contract for the Agent turn (Issue #3352).
-
-Provider prompt caching (Anthropic/OpenAI) only hits when the *leading* bytes
-of a request are byte-identical to the previous request. For a long-lived
-conversation the cached prefix — the system instructions, the serialised tool
-schemas, and the model identity — is the dominant cost and latency lever.
-
-Gateways run many users on a single shared ``Agent`` instance and swap
-``tools``/``llm`` in and out per turn (per-route tool scoping, per-user
-``/model`` override). Those swaps silently change the cached prefix and the
-provider cache misses with zero operator visibility.
-
-``prompt_prefix_signature`` gives callers a single, cheap, deterministic
-fingerprint of exactly the cache-relevant inputs — model, the sorted set of
-tool names, and a fingerprint of the system instructions — and *nothing*
-volatile per-turn (arrival time, routing facts, memory/RAG recall). When the
-signature is unchanged across turns the prefix is guaranteed stable, so the
-provider cache keeps hitting; when it changes, that is the one auditable point
-at which cache warmth is knowingly sacrificed.
-"""
-
-from __future__ import annotations
-
-import hashlib
-from typing import Any
-
-
-def _tool_name(tool: Any) -> str:
-    """Best-effort stable name for a tool entry.
-
-    Tools may be plain callables, dicts holding an OpenAI-style function
-    schema, or objects exposing ``__name__``/``name``. The name identifies the
-    schema slot in the serialised tool block.
-    """
-    if isinstance(tool, dict):
-        fn = tool.get("function")
-        if isinstance(fn, dict) and fn.get("name"):
-            return str(fn["name"])
-        for key in ("name", "type"):
-            if tool.get(key):
-                return str(tool[key])
-        return str(sorted(tool.keys()))
-    for attr in ("__name__", "name"):
-        value = getattr(tool, attr, None)
-        if value:
-            return str(value)
-    return str(tool)
-
-
-def _tool_fingerprint(tool: Any) -> str:
-    """Best-effort stable fingerprint of a tool's *provider-visible* schema.
-
-    The serialised tool block sent to the provider is not just the tool name —
-    it is the full function schema (name + description + parameters). A change
-    to a tool's description, parameters, or required fields *without* a rename
-    changes those bytes and therefore invalidates the prompt cache, so the
-    fingerprint must reflect the whole schema, not only the name (Issue #3352
-    review). Falls back to the name when no richer schema is exposed.
-    """
-    name = _tool_name(tool)
-
-    # Dict tools already carry an OpenAI-style function schema — fingerprint the
-    # description + parameters alongside the name so a same-name schema edit is
-    # detected. ``json.dumps(sort_keys=True)`` makes the render deterministic.
-    if isinstance(tool, dict):
-        fn = tool.get("function")
-        schema = fn if isinstance(fn, dict) else tool
-        desc = schema.get("description") if isinstance(schema, dict) else None
-        params = schema.get("parameters") if isinstance(schema, dict) else None
-        try:
-            import json
-
-            return "\x01".join(
-                (
-                    name,
-                    str(desc or ""),
-                    json.dumps(params or {}, sort_keys=True, default=str),
-                )
-            )
-        except Exception:  # pragma: no cover — defensive
-            return name
-
-    # Callable/object tools: fold in the docstring (the description the schema
-    # generator emits) so an edited tool doc flips the signature too.
-    doc = getattr(tool, "__doc__", None)
-    if doc:
-        return f"{name}\x01{doc}"
-    return name
-
-
-def prompt_prefix_signature(agent: Any) -> str:
-    """Return a sha256 signature of an agent's cache-relevant prompt prefix.
-
-    The signature is computed over, and only over:
-
-    * the model identity (``agent.llm``),
-    * the sorted set of tool *schema fingerprints* (name + description +
-      parameters, ``agent.tools``) — so a same-name schema edit is detected,
-    * a fingerprint of the system instructions (``agent.instructions``).
-
-    Volatile per-turn data is intentionally excluded so that an unchanged
-    route/model keeps a byte-identical prefix and the provider cache keeps
-    hitting. Callers compare the signature turn-over-turn: an unchanged value
-    means the cached prefix is reused; a changed value is the single auditable
-    point of prompt-cache invalidation.
-
-    Best-effort and never raises: any attribute access failure degrades the
-    corresponding component to an empty string rather than breaking the turn.
-    """
-    try:
-        llm = getattr(agent, "llm", None)
-        model = llm if isinstance(llm, str) else getattr(llm, "model", None) or str(llm)
-    except Exception:
-        model = ""
-
-    try:
-        tools = getattr(agent, "tools", None) or []
-        tool_fps = sorted(_tool_fingerprint(t) for t in tools)
-    except Exception:
-        tool_fps = []
-
-    try:
-        instructions = getattr(agent, "instructions", None) or ""
-        instructions = str(instructions)
-    except Exception:
-        instructions = ""
-
-    hasher = hashlib.sha256()
-    hasher.update(b"model\x00")
-    hasher.update(str(model).encode("utf-8", "replace"))
-    hasher.update(b"\x00tools\x00")
-    hasher.update("\x00".join(tool_fps).encode("utf-8", "replace"))
-    hasher.update(b"\x00instructions\x00")
-    hasher.update(instructions.encode("utf-8", "replace"))
-    return hasher.hexdigest()
-
-
-__all__ = ["prompt_prefix_signature"]

src/praisonai-agents/praisonaiagents/agent/router_agent.py

@@ -6,6 +6,7 @@ model selection based on task characteristics.
 """
 
 import os
+import logging
 from praisonaiagents._logging import get_logger
 from typing import Dict, List, Optional, Any, Union
 from .agent import Agent

src/praisonai-agents/praisonaiagents/agent/run_outcome.py

@@ -1,95 +0,0 @@
-"""Canonical terminal-outcome contract for agent runs.
-
-A single, closed description of *how* a run ended, produced once by the core
-run and consumed everywhere. Long-running hosts (e.g. gateways/bots) can make
-delivery/retry/DLQ/status decisions from one field instead of inferring the
-terminal state from exception identity.
-
-Precedence is explicit and sticky: a ``hard_timeout`` is never silently
-downgraded by later cleanup. See ``RunOutcome.from_exception``.
-"""
-
-from dataclasses import dataclass
-from typing import Optional
-try:
-    from typing import Literal
-except ImportError:  # pragma: no cover - py<3.8 fallback
-    Literal = None  # type: ignore
-
-if Literal is not None:
-    TerminalReason = Literal[
-        "completed", "hard_timeout", "cancelled", "aborted", "failed"
-    ]
-else:  # pragma: no cover
-    TerminalReason = str  # type: ignore
-
-# Precedence: higher wins and is sticky (a hard timeout is not downgraded).
-_REASON_PRECEDENCE = {
-    "completed": 0,
-    "failed": 1,
-    "aborted": 2,
-    "cancelled": 3,
-    "hard_timeout": 4,
-}
-
-
-@dataclass(frozen=True)
-class RunOutcome:
-    """Closed, canonical description of how an agent run ended.
-
-    Attributes:
-        reason: One of ``completed | hard_timeout | cancelled | aborted | failed``.
-        output: Partial or final text, if any.
-        error: Redacted message when ``reason == "failed"``.
-    """
-
-    reason: "TerminalReason"
-    output: Optional[str] = None
-    error: Optional[str] = None
-
-    @property
-    def succeeded(self) -> bool:
-        """True only when the run completed normally."""
-        return self.reason == "completed"
-
-    @classmethod
-    def completed(cls, output: Optional[str] = None) -> "RunOutcome":
-        return cls(reason="completed", output=output)
-
-    @classmethod
-    def from_exception(
-        cls, exc: BaseException, output: Optional[str] = None
-    ) -> "RunOutcome":
-        """Normalise a raised exception into a canonical terminal outcome.
-
-        Maps well-known exception types to their terminal reason. Anything
-        unrecognised is treated as ``failed`` with a redacted message.
-
-        Note on ``hard_timeout``: the run-level budget is the authoritative
-        source of ``hard_timeout`` and is applied explicitly by the caller
-        (see ``_astart_with_outcome``). A bare ``asyncio.TimeoutError`` reaching
-        this normaliser is a *nested* operation timeout (e.g. a handoff/tool that
-        exhausted its own budget while the run budget remained) and is therefore
-        classified as ``failed`` — not silently promoted to a run-budget
-        ``hard_timeout``, which would drive the wrong host retry/DLQ decision.
-        Real cooperative cancellation is intercepted and re-raised by the run
-        wrapper (see ``_astart_with_outcome``) *before* it reaches this
-        normaliser, so host shutdown is honoured. A supersede/interrupt named
-        error that does surface here is a domain "cancelled" outcome.
-        """
-        import asyncio
-
-        if _name_matches(exc, ("hardtimeout", "runtimeout", "budgettimeout")):
-            return cls(reason="hard_timeout", output=output)
-        if isinstance(exc, asyncio.CancelledError) or _name_matches(
-            exc, ("supersed", "interrupt", "cancelled")
-        ):
-            return cls(reason="cancelled", output=output)
-        if _name_matches(exc, ("abort", "drain", "shutdown")):
-            return cls(reason="aborted", output=output)
-        return cls(reason="failed", output=output, error=str(exc))
-
-
-def _name_matches(exc: BaseException, needles: tuple) -> bool:
-    name = type(exc).__name__.lower()
-    return any(n in name for n in needles)