import { Agent } from '@a3s-lab/code';

const agent = await Agent.create('agent.hcl');

const session = agent.session('.', {
  queueConfig: {
    queryConcurrency: 20,
    executeConcurrency: 5,
    enableMetrics: true,
    enableDlq: true
  }
});

await session.setLaneHandler('query', {
  mode: 'external',
  timeoutMs: 120_000
});

from a3s_code import Agent, SessionQueueConfig

agent = Agent.create("agent.hcl")

# Configure queue
queue_config = SessionQueueConfig(
    query_concurrency=20,
    execute_concurrency=5,
    enable_metrics=True,
    enable_dlq=True
)

session = agent.session(".", queue_config=queue_config)

# Configure Query lane for external processing
session.set_lane_handler(
    "query",
    {"mode": "external", "timeout_ms": 120_000}
)

import { AgentSession, ExternalTask, ExternalTaskResult } from '@a3s-lab/code';
import { exec } from 'child_process';
import { promisify } from 'util';
import { readFile } from 'fs/promises';

const execAsync = promisify(exec);

async function workerLoop(session: AgentSession): Promise<void> {
  while (true) {
    // Poll for pending tasks
    const tasks = await session.pendingExternalTasks();

    if (tasks.length === 0) {
      await new Promise(resolve => setTimeout(resolve, 100));
      continue;
    }

    // Process tasks in parallel
    await Promise.all(tasks.map(task => processTask(session, task)));
  }
}

async function processTask(session: AgentSession, task: ExternalTask): Promise<void> {
  const result = await executeTask(task);
  await session.completeExternalTask(task.taskId, result);
}

async function executeTask(task: ExternalTask): Promise<ExternalTaskResult> {
  switch (task.commandType) {
    case 'read': {
      const path = task.payload.path;
      try {
        const content = await readFile(path, 'utf-8');
        return {
          success: true,
          result: { content },
          error: null
        };
      } catch (e) {
        return {
          success: false,
          result: {},
          error: e.message
        };
      }
    }

    case 'bash': {
      const command = task.payload.command;
      try {
        const { stdout, stderr } = await execAsync(command);
        return {
          success: true,
          result: { stdout, stderr, exitCode: 0 },
          error: null
        };
      } catch (e) {
        return {
          success: false,
          result: { stdout: e.stdout, stderr: e.stderr, exitCode: e.code },
          error: e.message
        };
      }
    }

    default:
      return {
        success: false,
        result: {},
        error: `Unknown command type: ${task.commandType}`
      };
  }
}

import asyncio
from a3s_code import AgentSession, ExternalTaskResult

async def worker_loop(session: AgentSession):
    """Worker loop - can run on multiple machines"""
    while True:
        # Poll for pending tasks
        tasks = await session.pending_external_tasks()

        if not tasks:
            await asyncio.sleep(0.1)
            continue

        # Process tasks in parallel
        await asyncio.gather(*[
            process_task(session, task) for task in tasks
        ])

async def process_task(session: AgentSession, task):
    """Process a single task"""
    result = await execute_task(task)
    await session.complete_external_task(task.task_id, result)

async def execute_task(task):
    """Execute task based on command type"""
    if task.command_type == "read":
        path = task.payload["path"]
        try:
            with open(path, 'r') as f:
                content = f.read()
            return ExternalTaskResult(
                success=True,
                result={"content": content},
                error=None
            )
        except Exception as e:
            return ExternalTaskResult(
                success=False,
                result={},
                error=str(e)
            )

    elif task.command_type == "bash":
        command = task.payload["command"]
        try:
            proc = await asyncio.create_subprocess_shell(
                command,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE
            )
            stdout, stderr = await proc.communicate()
            return ExternalTaskResult(
                success=proc.returncode == 0,
                result={
                    "stdout": stdout.decode(),
                    "stderr": stderr.decode(),
                    "exit_code": proc.returncode
                },
                error=None
            )
        except Exception as e:
            return ExternalTaskResult(
                success=False,
                result={},
                error=str(e)
            )

    else:
        return ExternalTaskResult(
            success=False,
            result={},
            error=f"Unknown command type: {task.command_type}"
        )