@lakitu/sdk 0.1.42 → 0.1.44

package/convex/sandbox/agent/subagents.ts

@@ -266,38 +266,145 @@ export const spawn = internalAction({
 });
 
 /**
- * Execute subagent task with tool loop
- * @deprecated Legacy tool system removed - use code execution mode instead
+ * Run subagent code execution loop
+ * Uses the same pattern as the main agent - LLM generates code, we execute it.
  */
-async function runSubagentLoop(
-  _ctx: any,
-  _systemPrompt: string,
-  _task: string,
-  _toolNames: string[],
-  _model: string,
-  _maxSteps: number = 5
-): Promise<{ text: string; toolCalls: ToolCall[] }> {
-  throw new Error(
-    "Legacy subagent tool system is deprecated. Use code execution mode with KSAs instead."
-  );
-}
+async function runSubagentCodeExecLoop(
+  ctx: any,
+  systemPrompt: string,
+  task: string,
+  model: string,
+  maxSteps: number = 5,
+  onProgress?: (step: ChainOfThoughtStep) => Promise<void>
+): Promise<{ text: string; codeExecutions: Array<{ code: string; output: string; success: boolean }> }> {
+  const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: `Task: ${task}\n\nYou have access to KSAs (Knowledge, Skills, Abilities) via imports from './ksa/'. Write TypeScript code to accomplish this task.\n\nRespond with JSON containing:\n- "thinking": Your reasoning\n- "code": TypeScript code to execute (or empty if done)\n- "response": Final result when task is complete` },
+  ];
+
+  const allExecutions: Array<{ code: string; output: string; success: boolean }> = [];
+  let finalText = "";
+
+  for (let step = 0; step < maxSteps; step++) {
+    // Call LLM via local sandbox
+    let llmResponse: string;
+    try {
+      const res = await fetch("http://localhost:3210/api/action", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "agent/index:callLLM",
+          args: { messages, model },
+          format: "json",
+        }),
+      });
+      if (!res.ok) {
+        throw new Error(`LLM call failed: ${await res.text()}`);
+      }
+      const result = await res.json();
+      llmResponse = result.value?.text || result.value || "";
+    } catch (e: any) {
+      console.error("[subagent] LLM call failed:", e.message);
+      finalText = `Error: ${e.message}`;
+      break;
+    }
 
-/**
- * Execute subagent task with tool loop and progress emission
- * @deprecated Legacy tool system removed - use code execution mode instead
- */
-async function runSubagentLoopWithProgress(
-  _ctx: any,
-  _systemPrompt: string,
-  _task: string,
-  _toolNames: string[],
-  _model: string,
-  _maxSteps: number = 5,
-  _onProgress?: (step: ChainOfThoughtStep) => Promise<void>
-): Promise<{ text: string; toolCalls: ToolCall[] }> {
-  throw new Error(
-    "Legacy subagent tool system is deprecated. Use code execution mode with KSAs instead."
-  );
+    // Parse JSON response
+    let action: { thinking?: string; code?: string; response?: string } = {};
+    try {
+      const jsonMatch = llmResponse.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        action = JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+      // Try to extract code block directly
+      const codeMatch = llmResponse.match(/```(?:typescript|ts)?\s*([\s\S]*?)```/);
+      if (codeMatch) {
+        action = { code: codeMatch[1].trim() };
+      }
+    }
+
+    // Emit thinking progress
+    if (action.thinking && onProgress) {
+      await onProgress({
+        id: `step_${step}_thinking`,
+        type: "thinking",
+        label: action.thinking.slice(0, 150),
+        status: "complete",
+      });
+    }
+
+    // Check if done
+    if (action.response && !action.code) {
+      finalText = action.response;
+      break;
+    }
+
+    // Execute code
+    if (action.code && action.code.trim()) {
+      if (onProgress) {
+        await onProgress({
+          id: `step_${step}_code`,
+          type: "tool",
+          label: "Executing code...",
+          status: "active",
+        });
+      }
+
+      try {
+        const execResult = await ctx.runAction(internal.nodeActions.codeExec.execute, {
+          code: action.code,
+          timeoutMs: 60_000,
+          env: {
+            LOCAL_CONVEX_URL: "http://localhost:3210",
+          },
+        });
+
+        allExecutions.push({
+          code: action.code,
+          output: execResult.output,
+          success: execResult.success,
+        });
+
+        // Add to conversation
+        messages.push({
+          role: "assistant",
+          content: `Thinking: ${action.thinking || "..."}\n\n\`\`\`typescript\n${action.code}\n\`\`\``,
+        });
+        messages.push({
+          role: "user",
+          content: `Execution ${execResult.success ? "succeeded" : "failed"}:\n${execResult.output}\n\nContinue with JSON response.`,
+        });
+
+        if (onProgress) {
+          await onProgress({
+            id: `step_${step}_result`,
+            type: execResult.success ? "complete" : "error",
+            label: execResult.output.slice(0, 150),
+            status: execResult.success ? "complete" : "error",
+          });
+        }
+      } catch (e: any) {
+        allExecutions.push({
+          code: action.code,
+          output: e.message,
+          success: false,
+        });
+        messages.push({
+          role: "user",
+          content: `Execution error: ${e.message}\n\nTry a different approach.`,
+        });
+      }
+    } else if (!action.response) {
+      // No code and no response - try to continue
+      messages.push({
+        role: "user",
+        content: "Please provide either code to execute or a final response.",
+      });
+    }
+  }
+
+  return { text: finalText || "Subagent completed.", codeExecutions: allExecutions };
 }
 
 /**
@@ -369,11 +476,10 @@ Guidelines:
         );
       };
 
-      const result = await runSubagentLoopWithProgress(
+      const result = await runSubagentCodeExecLoop(
         ctx,
         systemPrompt,
         args.task,
-        args.tools,
         args.model || DEFAULT_SUBAGENT_MODEL,
         5,
         onProgress
@@ -385,7 +491,7 @@ Guidelines:
         status: "completed",
         result: {
           text: result.text,
-          toolCalls: result.toolCalls,
+          codeExecutions: result.codeExecutions,
         },
       });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakitu/sdk",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Self-hosted AI agent framework for Convex + E2B with code execution",
   "type": "module",
   "main": "./dist/sdk/index.js",

package/template/e2b/start.sh

@@ -1,55 +1,60 @@
 #!/bin/bash
-# Start convex-backend and deploy functions if needed
+# Start convex-backend with pre-deployed functions
 
 STORAGE_DIR=/home/user/.convex/convex-backend-state/lakitu
 SQLITE_DB=$STORAGE_DIR/convex_local_backend.sqlite3
 MODULES_DIR=$STORAGE_DIR/modules
 
-# Start convex-backend in background
-convex-backend \
-  "$SQLITE_DB" \
-  --port 3210 \
-  --site-proxy-port 3211 \
-  --local-storage "$STORAGE_DIR" \
-  --disable-beacon &
-
-BACKEND_PID=$!
-
-# Wait for backend to be ready
-for i in {1..30}; do
-  if curl -s http://127.0.0.1:3210/version > /dev/null 2>&1; then
-    echo "Backend ready"
-    break
-  fi
-  sleep 1
-done
-
-# Deploy functions if not already deployed
+# Deploy functions FIRST if not already deployed
 if [ ! -d "$MODULES_DIR" ] || [ -z "$(ls -A $MODULES_DIR 2>/dev/null)" ]; then
-  echo "Deploying Convex functions..."
+  echo "Pre-deploying Convex functions..."
+  
+  # Start temp backend on different port for deployment
+  convex-backend \
+    "$SQLITE_DB" \
+    --port 3209 \
+    --site-proxy-port 3208 \
+    --local-storage "$STORAGE_DIR" \
+    --disable-beacon &
+  TEMP_PID=$!
+  
+  # Wait for temp backend
+  for i in {1..30}; do
+    if curl -s http://127.0.0.1:3209/version > /dev/null 2>&1; then
+      break
+    fi
+    sleep 1
+  done
+  
+  # Deploy functions
   cd /home/user/lakitu
-  export CONVEX_SELF_HOSTED_URL=http://127.0.0.1:3210
+  export CONVEX_SELF_HOSTED_URL=http://127.0.0.1:3209
   export CONVEX_SELF_HOSTED_ADMIN_KEY=0135d8598650f8f5cb0f30c34ec2e2bb62793bc28717c8eb6fb577996d50be5f4281b59181095065c5d0f86a2c31ddbe9b597ec62b47ded69782cd
   
-  # Run deployment and wait for completion
   if npx convex dev --once --typecheck disable > /tmp/convex-deploy.log 2>&1; then
     echo "Functions deployed successfully"
   else
-    echo "Function deployment failed, check /tmp/convex-deploy.log"
+    echo "Deploy failed:"
     cat /tmp/convex-deploy.log
   fi
   
-  # Wait for modules to be ready (up to 30 seconds)
-  echo "Waiting for modules..."
-  for i in {1..30}; do
-    if [ -d "$MODULES_DIR" ] && [ -n "$(ls -A $MODULES_DIR 2>/dev/null)" ]; then
-      MODULE_COUNT=$(ls -1 $MODULES_DIR | wc -l)
-      echo "Modules ready: $MODULE_COUNT files"
-      break
-    fi
-    sleep 1
-  done
+  # Stop temp backend
+  kill $TEMP_PID 2>/dev/null
+  sleep 1
+  
+  # Verify deployment
+  if [ -d "$MODULES_DIR" ] && [ -n "$(ls -A $MODULES_DIR 2>/dev/null)" ]; then
+    MODULE_COUNT=$(ls -1 $MODULES_DIR | wc -l)
+    echo "Deployed $MODULE_COUNT modules"
+  else
+    echo "WARNING: No modules deployed"
+  fi
 fi
 
-# Wait for backend process
-wait $BACKEND_PID
+# Now start the main backend on correct port
+exec convex-backend \
+  "$SQLITE_DB" \
+  --port 3210 \
+  --site-proxy-port 3211 \
+  --local-storage "$STORAGE_DIR" \
+  --disable-beacon